Coverage Report - com.googlecode.sparkleg.SparqlParser
 
Classes in this File Line Coverage Branch Coverage Complexity
SparqlParser
89%
10048/11231
24%
1215/4886
11,672
SparqlParser$DFA4
95%
22/23
N/A
11,672
SparqlParser$add_return
0%
0/2
N/A
11,672
SparqlParser$additiveExpression_return
100%
4/4
N/A
11,672
SparqlParser$additiveOperator_return
100%
4/4
N/A
11,672
SparqlParser$aggregate_return
100%
4/4
N/A
11,672
SparqlParser$anon_return
100%
4/4
N/A
11,672
SparqlParser$argList_return
100%
2/2
N/A
11,672
SparqlParser$askQuery_return
100%
2/2
N/A
11,672
SparqlParser$baseDecl_return
100%
2/2
N/A
11,672
SparqlParser$bind_return
100%
2/2
N/A
11,672
SparqlParser$bindingValueList_return
100%
2/2
N/A
11,672
SparqlParser$bindingValue_return
100%
2/2
N/A
11,672
SparqlParser$bindingsClause_return
100%
2/2
N/A
11,672
SparqlParser$blankNode_return
100%
4/4
N/A
11,672
SparqlParser$booleanLiteral_return
100%
4/4
N/A
11,672
SparqlParser$brackettedExpression_return
100%
4/4
N/A
11,672
SparqlParser$builtInCall_return
100%
4/4
N/A
11,672
SparqlParser$clear_return
100%
2/2
N/A
11,672
SparqlParser$conditionalAndExpression_return
100%
4/4
N/A
11,672
SparqlParser$conditionalOrExpression_return
100%
4/4
N/A
11,672
SparqlParser$constraint_return
100%
2/2
N/A
11,672
SparqlParser$constructQuery_return
100%
2/2
N/A
11,672
SparqlParser$constructTemplate_return
100%
2/2
N/A
11,672
SparqlParser$constructTriples_return
100%
2/2
N/A
11,672
SparqlParser$copy_return
0%
0/2
N/A
11,672
SparqlParser$create_return
0%
0/2
N/A
11,672
SparqlParser$datasetClause_return
100%
2/2
N/A
11,672
SparqlParser$deleteClause_return
100%
2/2
N/A
11,672
SparqlParser$deleteData_return
100%
2/2
N/A
11,672
SparqlParser$deleteWhere_return
100%
2/2
N/A
11,672
SparqlParser$delete_return
100%
2/2
N/A
11,672
SparqlParser$describeQuery_return
100%
2/2
N/A
11,672
SparqlParser$drop_return
100%
2/2
N/A
11,672
SparqlParser$existsFunction_return
100%
4/4
N/A
11,672
SparqlParser$expressionList_return
100%
2/2
N/A
11,672
SparqlParser$expression_return
100%
4/4
N/A
11,672
SparqlParser$filter_return
100%
2/2
N/A
11,672
SparqlParser$functionCall_return
100%
2/2
N/A
11,672
SparqlParser$graphGraphPattern_return
100%
2/2
N/A
11,672
SparqlParser$graphNode_return
100%
4/4
N/A
11,672
SparqlParser$graphOrDefault_return
0%
0/2
N/A
11,672
SparqlParser$graphPatternNotTriples_return
100%
2/2
N/A
11,672
SparqlParser$graphRefAll_return
100%
2/2
N/A
11,672
SparqlParser$graphRef_return
100%
2/2
N/A
11,672
SparqlParser$graphTerm_return
100%
4/4
N/A
11,672
SparqlParser$groupClause_return
100%
2/2
N/A
11,672
SparqlParser$groupCondition_return
100%
2/2
N/A
11,672
SparqlParser$groupGraphPatternSubDetail_return
100%
2/2
N/A
11,672
SparqlParser$groupGraphPatternSub_return
100%
2/2
N/A
11,672
SparqlParser$groupGraphPattern_return
100%
2/2
N/A
11,672
SparqlParser$groupOrUnionGraphPattern_return
100%
2/2
N/A
11,672
SparqlParser$havingClause_return
100%
2/2
N/A
11,672
SparqlParser$insertClause_return
100%
2/2
N/A
11,672
SparqlParser$insert_return
100%
2/2
N/A
11,672
SparqlParser$iriRefOrFunction_return
100%
4/4
N/A
11,672
SparqlParser$iriRef_return
100%
4/4
N/A
11,672
SparqlParser$limitClause_return
100%
2/2
N/A
11,672
SparqlParser$limitOffsetClauses_return
100%
2/2
N/A
11,672
SparqlParser$load_return
0%
0/2
N/A
11,672
SparqlParser$minusGraphPattern_return
100%
2/2
N/A
11,672
SparqlParser$modify_return
100%
2/2
N/A
11,672
SparqlParser$move_return
0%
0/2
N/A
11,672
SparqlParser$multiplicativeExpression_return
100%
4/4
N/A
11,672
SparqlParser$multiplicativeOperator_return
100%
4/4
N/A
11,672
SparqlParser$nil_return
100%
4/4
N/A
11,672
SparqlParser$notExistsFunction_return
100%
4/4
N/A
11,672
SparqlParser$numericExpression_return
100%
4/4
N/A
11,672
SparqlParser$numericLiteralNegative_return
100%
4/4
N/A
11,672
SparqlParser$numericLiteralPositive_return
100%
4/4
N/A
11,672
SparqlParser$numericLiteralUnsigned_return
100%
4/4
N/A
11,672
SparqlParser$numericLiteral_return
100%
4/4
N/A
11,672
SparqlParser$objectList_return
100%
2/2
N/A
11,672
SparqlParser$offsetClause_return
100%
2/2
N/A
11,672
SparqlParser$optionalGraphPattern_return
100%
2/2
N/A
11,672
SparqlParser$orderClause_return
100%
2/2
N/A
11,672
SparqlParser$orderCondition_return
100%
2/2
N/A
11,672
SparqlParser$pathEltOrInverse_return
100%
2/2
N/A
11,672
SparqlParser$pathElt_return
100%
2/2
N/A
11,672
SparqlParser$pathMod_return
100%
2/2
N/A
11,672
SparqlParser$pathNegatedPropertySet_return
100%
2/2
N/A
11,672
SparqlParser$pathOneInPropertySet_return
100%
4/4
N/A
11,672
SparqlParser$pathPrimary_return
100%
2/2
N/A
11,672
SparqlParser$pathSequence_return
100%
2/2
N/A
11,672
SparqlParser$path_return
100%
2/2
N/A
11,672
SparqlParser$prefixDecl_return
100%
2/2
N/A
11,672
SparqlParser$prefixedName_return
100%
4/4
N/A
11,672
SparqlParser$primaryExpression_return
100%
4/4
N/A
11,672
SparqlParser$prologue_return
100%
2/2
N/A
11,672
SparqlParser$propertyListNotEmptyDetails_return
100%
2/2
N/A
11,672
SparqlParser$propertyListNotEmptyPath_return
100%
2/2
N/A
11,672
SparqlParser$propertyListNotEmpty_return
100%
2/2
N/A
11,672
SparqlParser$quadPattern_return
100%
2/2
N/A
11,672
SparqlParser$quadsNotTriples_return
100%
2/2
N/A
11,672
SparqlParser$quads_return
100%
2/2
N/A
11,672
SparqlParser$query_return
100%
2/2
N/A
11,672
SparqlParser$rdfLiteral_return
100%
4/4
N/A
11,672
SparqlParser$regexExpression_return
100%
4/4
N/A
11,672
SparqlParser$relationalExpression_return
100%
4/4
N/A
11,672
SparqlParser$selectClause_return
100%
2/2
N/A
11,672
SparqlParser$selectQuery_return
100%
2/2
N/A
11,672
SparqlParser$selectVariables_return
100%
2/2
N/A
11,672
SparqlParser$serviceGraphPattern_return
100%
2/2
N/A
11,672
SparqlParser$solutionModifier_return
100%
2/2
N/A
11,672
SparqlParser$string_return
100%
4/4
N/A
11,672
SparqlParser$subSelect_return
100%
2/2
N/A
11,672
SparqlParser$subStringExpression_return
100%
4/4
N/A
11,672
SparqlParser$triplesBlock_return
100%
2/2
N/A
11,672
SparqlParser$triplesNode_return
100%
4/4
N/A
11,672
SparqlParser$triplesSameSubjectPath_return
100%
2/2
N/A
11,672
SparqlParser$triplesSameSubject_return
100%
2/2
N/A
11,672
SparqlParser$triplesTemplate_return
100%
2/2
N/A
11,672
SparqlParser$unaryExpression_return
100%
4/4
N/A
11,672
SparqlParser$update_return
100%
2/2
N/A
11,672
SparqlParser$usingClause_return
100%
2/2
N/A
11,672
SparqlParser$valueLogical_return
100%
4/4
N/A
11,672
SparqlParser$varOrIRIref_return
100%
4/4
N/A
11,672
SparqlParser$varOrTerm_return
100%
4/4
N/A
11,672
SparqlParser$var_return
100%
4/4
N/A
11,672
SparqlParser$verbPath_return
100%
2/2
N/A
11,672
SparqlParser$verbSimpleOrPath_return
100%
2/2
N/A
11,672
SparqlParser$verbSimple_return
100%
2/2
N/A
11,672
SparqlParser$verb_return
0%
0/2
N/A
11,672
SparqlParser$whereClause_return
100%
2/2
N/A
11,672
 
 1  
 // $ANTLR 3.4 com\\googlecode\\sparkleg\\Sparql.g 2011-12-06 23:49:47
 2  
 
 3  
     package com.googlecode.sparkleg;
 4  
 
 5  
 
 6  
 import org.antlr.runtime.*;
 7  
 import java.util.Stack;
 8  
 import java.util.List;
 9  
 import java.util.ArrayList;
 10  
 
 11  
 import org.antlr.runtime.tree.*;
 12  
 
 13  
 
 14  
 /**
 15  
  * @author Simone Tripodi   (simone.tripodi)
 16  
  * @author Michele Mostarda (michele.mostarda)
 17  
  * @author Juergen Pfundt   (Juergen.Pfundt)
 18  
  * @version $Id: Sparql.g 226 2011-10-22 21:13:52Z Juergen.Pfundt@gmail.com $
 19  
  */
 20  
 @SuppressWarnings({"all", "warnings", "unchecked"})
 21  
 public class SparqlParser extends Parser {
 22  2
     public static final String[] tokenNames = new String[] {
 23  
         "<invalid>", "<EOR>", "<DOWN>", "<UP>", "A", "ABS", "ADD", "ALL", "AND", "ANY", "ARG_LIST", "AS", "ASC", "ASK", "ASTERISK", "AVG", "BASE", "BIND", "BINDINGS", "BINDING_VALUE", "BLANK_NODE", "BLANK_NODE_LABEL", "BNODE", "BOUND", "BRACKETTED_EXPRESSION", "BY", "CEIL", "CLEAR", "CLOSE_BRACE", "CLOSE_CURLY_BRACE", "CLOSE_SQUARE_BRACKET", "COALESCE", "COLLECTION", "COMMA", "COMMENT", "CONCAT", "CONSTRUCT", "CONSTRUCT_TRIPLES", "CONTAINS", "COPY", "COUNT", "CREATE", "DATA", "DATATYPE", "DAY", "DECIMAL", "DECIMAL_NEGATIVE", "DECIMAL_POSITIVE", "DEFAULT", "DELETE", "DESC", "DESCRIBE", "DIGIT", "DISTINCT", "DIVIDE", "DOT", "DOUBLE", "DOUBLE_NEGATIVE", "DOUBLE_POSITIVE", "DROP", "ECHAR", "ENCODE_FOR_URI", "EOL", "EQUAL", "EXISTS", "EXPONENT", "EXPRESSION_LIST", "FALSE", "FILTER", "FLOOR", "FROM", "FUNCTION", "GRAPH", "GREATER", "GREATER_EQUAL", "GROUP", "GROUP_BY", "GROUP_CONCAT", "GROUP_CONDITION", "GROUP_GRAPH_PATTERN", "HAVING", "HOURS", "IF", "IN", "INSERT", "INTEGER", "INTEGER_NEGATIVE", "INTEGER_POSITIVE", "INTO", "INVERSE", "IRI", "IRI_REF", "IRI_REF_CHARACTERS", "ISBLANK", "ISIRI", "ISLITERAL", "ISNUMERIC", "ISURI", "LANG", "LANGMATCHES", "LANGTAG", "LCASE", "LESS", "LESS_EQUAL", "LIMIT", "LOAD", "MAX", "MD5", "MIN", "MINUS", "MINUS_KEYWORD", "MINUTES", "MODIFY", "MONTH", "MOVE", "NAMED", "NEGATION", "NOT", "NOT_EQUAL", "NOT_EXISTS", "NOW", "OBJECT", "OFFSET", "OPEN_BRACE", "OPEN_CURLY_BRACE", "OPEN_SQUARE_BRACKET", "OPTIONAL", "OR", "ORDER", "ORDER_BY", "ORDER_CONDITION", "PATH", "PATH_NEGATED", "PATH_PRIMARY", "PATH_SEQUENCE", "PIPE", "PLUS", "PNAME_LN", "PNAME_NS", "PN_CHARS", "PN_CHARS_BASE", "PN_CHARS_U", "PN_LOCAL", "PN_PREFIX", "PREDICATE", "PREFIX", "PROLOGUE", "QUERY", "QUESTION_MARK", "RAND", "REDUCED", "REFERENCE", "REGEX", "REPLACE", "ROUND", "SAMETERM", "SAMPLE", "SECONDS", "SELECT", "SELECT_CLAUSE", "SEMICOLON", "SEPARATOR", "SERVICE", "SHA1", "SHA224", "SHA256", "SHA384", "SHA512", "SIGN", "SILENT", "STR", "STRAFTER", "STRBEFORE", "STRDT", "STRENDS", "STRING_LITERAL1", "STRING_LITERAL2", "STRING_LITERAL_LONG1", "STRING_LITERAL_LONG2", "STRLANG", "STRLEN", "STRSTARTS", "SUBJECT", "SUBSELECT", "SUBSTR", "SUM", "TIMEZONE", "TO", "TRIPLES_BLOCK", "TRIPLES_NODE", "TRIPLES_SAME_SUBJECT", "TRIPLES_TEMPLATE", "TRUE", "TZ", "UCASE", "UNARY", "UNDEF", "UNION", "UPDATE", "URI", "USING", "VAR", "VAR1", "VAR2", "VARNAME", "WHERE", "WHERE_CLAUSE", "WITH", "WS", "YEAR"
 24  
     };
 25  
 
 26  
     public static final int EOF=-1;
 27  
     public static final int A=4;
 28  
     public static final int ABS=5;
 29  
     public static final int ADD=6;
 30  
     public static final int ALL=7;
 31  
     public static final int AND=8;
 32  
     public static final int ANY=9;
 33  
     public static final int ARG_LIST=10;
 34  
     public static final int AS=11;
 35  
     public static final int ASC=12;
 36  
     public static final int ASK=13;
 37  
     public static final int ASTERISK=14;
 38  
     public static final int AVG=15;
 39  
     public static final int BASE=16;
 40  
     public static final int BIND=17;
 41  
     public static final int BINDINGS=18;
 42  
     public static final int BINDING_VALUE=19;
 43  
     public static final int BLANK_NODE=20;
 44  
     public static final int BLANK_NODE_LABEL=21;
 45  
     public static final int BNODE=22;
 46  
     public static final int BOUND=23;
 47  
     public static final int BRACKETTED_EXPRESSION=24;
 48  
     public static final int BY=25;
 49  
     public static final int CEIL=26;
 50  
     public static final int CLEAR=27;
 51  
     public static final int CLOSE_BRACE=28;
 52  
     public static final int CLOSE_CURLY_BRACE=29;
 53  
     public static final int CLOSE_SQUARE_BRACKET=30;
 54  
     public static final int COALESCE=31;
 55  
     public static final int COLLECTION=32;
 56  
     public static final int COMMA=33;
 57  
     public static final int COMMENT=34;
 58  
     public static final int CONCAT=35;
 59  
     public static final int CONSTRUCT=36;
 60  
     public static final int CONSTRUCT_TRIPLES=37;
 61  
     public static final int CONTAINS=38;
 62  
     public static final int COPY=39;
 63  
     public static final int COUNT=40;
 64  
     public static final int CREATE=41;
 65  
     public static final int DATA=42;
 66  
     public static final int DATATYPE=43;
 67  
     public static final int DAY=44;
 68  
     public static final int DECIMAL=45;
 69  
     public static final int DECIMAL_NEGATIVE=46;
 70  
     public static final int DECIMAL_POSITIVE=47;
 71  
     public static final int DEFAULT=48;
 72  
     public static final int DELETE=49;
 73  
     public static final int DESC=50;
 74  
     public static final int DESCRIBE=51;
 75  
     public static final int DIGIT=52;
 76  
     public static final int DISTINCT=53;
 77  
     public static final int DIVIDE=54;
 78  
     public static final int DOT=55;
 79  
     public static final int DOUBLE=56;
 80  
     public static final int DOUBLE_NEGATIVE=57;
 81  
     public static final int DOUBLE_POSITIVE=58;
 82  
     public static final int DROP=59;
 83  
     public static final int ECHAR=60;
 84  
     public static final int ENCODE_FOR_URI=61;
 85  
     public static final int EOL=62;
 86  
     public static final int EQUAL=63;
 87  
     public static final int EXISTS=64;
 88  
     public static final int EXPONENT=65;
 89  
     public static final int EXPRESSION_LIST=66;
 90  
     public static final int FALSE=67;
 91  
     public static final int FILTER=68;
 92  
     public static final int FLOOR=69;
 93  
     public static final int FROM=70;
 94  
     public static final int FUNCTION=71;
 95  
     public static final int GRAPH=72;
 96  
     public static final int GREATER=73;
 97  
     public static final int GREATER_EQUAL=74;
 98  
     public static final int GROUP=75;
 99  
     public static final int GROUP_BY=76;
 100  
     public static final int GROUP_CONCAT=77;
 101  
     public static final int GROUP_CONDITION=78;
 102  
     public static final int GROUP_GRAPH_PATTERN=79;
 103  
     public static final int HAVING=80;
 104  
     public static final int HOURS=81;
 105  
     public static final int IF=82;
 106  
     public static final int IN=83;
 107  
     public static final int INSERT=84;
 108  
     public static final int INTEGER=85;
 109  
     public static final int INTEGER_NEGATIVE=86;
 110  
     public static final int INTEGER_POSITIVE=87;
 111  
     public static final int INTO=88;
 112  
     public static final int INVERSE=89;
 113  
     public static final int IRI=90;
 114  
     public static final int IRI_REF=91;
 115  
     public static final int IRI_REF_CHARACTERS=92;
 116  
     public static final int ISBLANK=93;
 117  
     public static final int ISIRI=94;
 118  
     public static final int ISLITERAL=95;
 119  
     public static final int ISNUMERIC=96;
 120  
     public static final int ISURI=97;
 121  
     public static final int LANG=98;
 122  
     public static final int LANGMATCHES=99;
 123  
     public static final int LANGTAG=100;
 124  
     public static final int LCASE=101;
 125  
     public static final int LESS=102;
 126  
     public static final int LESS_EQUAL=103;
 127  
     public static final int LIMIT=104;
 128  
     public static final int LOAD=105;
 129  
     public static final int MAX=106;
 130  
     public static final int MD5=107;
 131  
     public static final int MIN=108;
 132  
     public static final int MINUS=109;
 133  
     public static final int MINUS_KEYWORD=110;
 134  
     public static final int MINUTES=111;
 135  
     public static final int MODIFY=112;
 136  
     public static final int MONTH=113;
 137  
     public static final int MOVE=114;
 138  
     public static final int NAMED=115;
 139  
     public static final int NEGATION=116;
 140  
     public static final int NOT=117;
 141  
     public static final int NOT_EQUAL=118;
 142  
     public static final int NOT_EXISTS=119;
 143  
     public static final int NOW=120;
 144  
     public static final int OBJECT=121;
 145  
     public static final int OFFSET=122;
 146  
     public static final int OPEN_BRACE=123;
 147  
     public static final int OPEN_CURLY_BRACE=124;
 148  
     public static final int OPEN_SQUARE_BRACKET=125;
 149  
     public static final int OPTIONAL=126;
 150  
     public static final int OR=127;
 151  
     public static final int ORDER=128;
 152  
     public static final int ORDER_BY=129;
 153  
     public static final int ORDER_CONDITION=130;
 154  
     public static final int PATH=131;
 155  
     public static final int PATH_NEGATED=132;
 156  
     public static final int PATH_PRIMARY=133;
 157  
     public static final int PATH_SEQUENCE=134;
 158  
     public static final int PIPE=135;
 159  
     public static final int PLUS=136;
 160  
     public static final int PNAME_LN=137;
 161  
     public static final int PNAME_NS=138;
 162  
     public static final int PN_CHARS=139;
 163  
     public static final int PN_CHARS_BASE=140;
 164  
     public static final int PN_CHARS_U=141;
 165  
     public static final int PN_LOCAL=142;
 166  
     public static final int PN_PREFIX=143;
 167  
     public static final int PREDICATE=144;
 168  
     public static final int PREFIX=145;
 169  
     public static final int PROLOGUE=146;
 170  
     public static final int QUERY=147;
 171  
     public static final int QUESTION_MARK=148;
 172  
     public static final int RAND=149;
 173  
     public static final int REDUCED=150;
 174  
     public static final int REFERENCE=151;
 175  
     public static final int REGEX=152;
 176  
     public static final int REPLACE=153;
 177  
     public static final int ROUND=154;
 178  
     public static final int SAMETERM=155;
 179  
     public static final int SAMPLE=156;
 180  
     public static final int SECONDS=157;
 181  
     public static final int SELECT=158;
 182  
     public static final int SELECT_CLAUSE=159;
 183  
     public static final int SEMICOLON=160;
 184  
     public static final int SEPARATOR=161;
 185  
     public static final int SERVICE=162;
 186  
     public static final int SHA1=163;
 187  
     public static final int SHA224=164;
 188  
     public static final int SHA256=165;
 189  
     public static final int SHA384=166;
 190  
     public static final int SHA512=167;
 191  
     public static final int SIGN=168;
 192  
     public static final int SILENT=169;
 193  
     public static final int STR=170;
 194  
     public static final int STRAFTER=171;
 195  
     public static final int STRBEFORE=172;
 196  
     public static final int STRDT=173;
 197  
     public static final int STRENDS=174;
 198  
     public static final int STRING_LITERAL1=175;
 199  
     public static final int STRING_LITERAL2=176;
 200  
     public static final int STRING_LITERAL_LONG1=177;
 201  
     public static final int STRING_LITERAL_LONG2=178;
 202  
     public static final int STRLANG=179;
 203  
     public static final int STRLEN=180;
 204  
     public static final int STRSTARTS=181;
 205  
     public static final int SUBJECT=182;
 206  
     public static final int SUBSELECT=183;
 207  
     public static final int SUBSTR=184;
 208  
     public static final int SUM=185;
 209  
     public static final int TIMEZONE=186;
 210  
     public static final int TO=187;
 211  
     public static final int TRIPLES_BLOCK=188;
 212  
     public static final int TRIPLES_NODE=189;
 213  
     public static final int TRIPLES_SAME_SUBJECT=190;
 214  
     public static final int TRIPLES_TEMPLATE=191;
 215  
     public static final int TRUE=192;
 216  
     public static final int TZ=193;
 217  
     public static final int UCASE=194;
 218  
     public static final int UNARY=195;
 219  
     public static final int UNDEF=196;
 220  
     public static final int UNION=197;
 221  
     public static final int UPDATE=198;
 222  
     public static final int URI=199;
 223  
     public static final int USING=200;
 224  
     public static final int VAR=201;
 225  
     public static final int VAR1=202;
 226  
     public static final int VAR2=203;
 227  
     public static final int VARNAME=204;
 228  
     public static final int WHERE=205;
 229  
     public static final int WHERE_CLAUSE=206;
 230  
     public static final int WITH=207;
 231  
     public static final int WS=208;
 232  
     public static final int YEAR=209;
 233  
 
 234  
     // delegates
 235  
     public Parser[] getDelegates() {
 236  0
         return new Parser[] {};
 237  
     }
 238  
 
 239  
     // delegators
 240  
 
 241  
 
 242  
     public SparqlParser(TokenStream input) {
 243  1958
         this(input, new RecognizerSharedState());
 244  1958
     }
 245  
     public SparqlParser(TokenStream input, RecognizerSharedState state) {
 246  1958
         super(input, state);
 247  1958
     }
 248  
 
 249  1958
 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
 250  
 
 251  
 public void setTreeAdaptor(TreeAdaptor adaptor) {
 252  0
     this.adaptor = adaptor;
 253  0
 }
 254  
 public TreeAdaptor getTreeAdaptor() {
 255  0
     return adaptor;
 256  
 }
 257  106
     public String[] getTokenNames() { return SparqlParser.tokenNames; }
 258  0
     public String getGrammarFileName() { return "com\\googlecode\\sparkleg\\Sparql.g"; }
 259  
 
 260  
 
 261  1958
     public static class query_return extends ParserRuleReturnScope {
 262  
         Object tree;
 263  1958
         public Object getTree() { return tree; }
 264  
     };
 265  
 
 266  
 
 267  
     // $ANTLR start "query"
 268  
     // com\\googlecode\\sparkleg\\Sparql.g:76:1: query : ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( SEMICOLON ( update )? )* EOF -> ^( UPDATE ( update )+ ) );
 269  
     public final SparqlParser.query_return query() throws RecognitionException {
 270  1958
         SparqlParser.query_return retval = new SparqlParser.query_return();
 271  1958
         retval.start = input.LT(1);
 272  
 
 273  
 
 274  1958
         Object root_0 = null;
 275  
 
 276  1958
         Token EOF7=null;
 277  1958
         Token SEMICOLON9=null;
 278  1958
         Token EOF11=null;
 279  1958
         SparqlParser.prologue_return prologue1 =null;
 280  
 
 281  1958
         SparqlParser.selectQuery_return selectQuery2 =null;
 282  
 
 283  1958
         SparqlParser.constructQuery_return constructQuery3 =null;
 284  
 
 285  1958
         SparqlParser.describeQuery_return describeQuery4 =null;
 286  
 
 287  1958
         SparqlParser.askQuery_return askQuery5 =null;
 288  
 
 289  1958
         SparqlParser.bindingsClause_return bindingsClause6 =null;
 290  
 
 291  1958
         SparqlParser.update_return update8 =null;
 292  
 
 293  1958
         SparqlParser.update_return update10 =null;
 294  
 
 295  
 
 296  1958
         Object EOF7_tree=null;
 297  1958
         Object SEMICOLON9_tree=null;
 298  1958
         Object EOF11_tree=null;
 299  1958
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 300  1958
         RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
 301  1958
         RewriteRuleSubtreeStream stream_update=new RewriteRuleSubtreeStream(adaptor,"rule update");
 302  1958
         RewriteRuleSubtreeStream stream_describeQuery=new RewriteRuleSubtreeStream(adaptor,"rule describeQuery");
 303  1958
         RewriteRuleSubtreeStream stream_bindingsClause=new RewriteRuleSubtreeStream(adaptor,"rule bindingsClause");
 304  1958
         RewriteRuleSubtreeStream stream_constructQuery=new RewriteRuleSubtreeStream(adaptor,"rule constructQuery");
 305  1958
         RewriteRuleSubtreeStream stream_askQuery=new RewriteRuleSubtreeStream(adaptor,"rule askQuery");
 306  1958
         RewriteRuleSubtreeStream stream_prologue=new RewriteRuleSubtreeStream(adaptor,"rule prologue");
 307  1958
         RewriteRuleSubtreeStream stream_selectQuery=new RewriteRuleSubtreeStream(adaptor,"rule selectQuery");
 308  
         try {
 309  
             // com\\googlecode\\sparkleg\\Sparql.g:77:5: ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( SEMICOLON ( update )? )* EOF -> ^( UPDATE ( update )+ ) )
 310  1958
             int alt4=2;
 311  1958
             alt4 = dfa4.predict(input);
 312  1958
             switch (alt4) {
 313  
                 case 1 :
 314  
                     // com\\googlecode\\sparkleg\\Sparql.g:77:7: prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF
 315  
                     {
 316  1834
                     pushFollow(FOLLOW_prologue_in_query155);
 317  1834
                     prologue1=prologue();
 318  
 
 319  1834
                     state._fsp--;
 320  
 
 321  1834
                     stream_prologue.add(prologue1.getTree());
 322  
 
 323  
                     // com\\googlecode\\sparkleg\\Sparql.g:77:16: ( selectQuery | constructQuery | describeQuery | askQuery )
 324  1834
                     int alt1=4;
 325  1834
                     switch ( input.LA(1) ) {
 326  
                     case SELECT:
 327  
                         {
 328  1614
                         alt1=1;
 329  
                         }
 330  1614
                         break;
 331  
                     case CONSTRUCT:
 332  
                         {
 333  72
                         alt1=2;
 334  
                         }
 335  72
                         break;
 336  
                     case DESCRIBE:
 337  
                         {
 338  28
                         alt1=3;
 339  
                         }
 340  28
                         break;
 341  
                     case ASK:
 342  
                         {
 343  120
                         alt1=4;
 344  
                         }
 345  120
                         break;
 346  
                     default:
 347  0
                         NoViableAltException nvae =
 348  
                             new NoViableAltException("", 1, 0, input);
 349  
 
 350  0
                         throw nvae;
 351  
 
 352  
                     }
 353  
 
 354  1834
                     switch (alt1) {
 355  
                         case 1 :
 356  
                             // com\\googlecode\\sparkleg\\Sparql.g:77:17: selectQuery
 357  
                             {
 358  1614
                             pushFollow(FOLLOW_selectQuery_in_query158);
 359  1614
                             selectQuery2=selectQuery();
 360  
 
 361  1614
                             state._fsp--;
 362  
 
 363  1614
                             stream_selectQuery.add(selectQuery2.getTree());
 364  
 
 365  
                             }
 366  1614
                             break;
 367  
                         case 2 :
 368  
                             // com\\googlecode\\sparkleg\\Sparql.g:77:31: constructQuery
 369  
                             {
 370  72
                             pushFollow(FOLLOW_constructQuery_in_query162);
 371  72
                             constructQuery3=constructQuery();
 372  
 
 373  72
                             state._fsp--;
 374  
 
 375  72
                             stream_constructQuery.add(constructQuery3.getTree());
 376  
 
 377  
                             }
 378  72
                             break;
 379  
                         case 3 :
 380  
                             // com\\googlecode\\sparkleg\\Sparql.g:77:48: describeQuery
 381  
                             {
 382  28
                             pushFollow(FOLLOW_describeQuery_in_query166);
 383  28
                             describeQuery4=describeQuery();
 384  
 
 385  28
                             state._fsp--;
 386  
 
 387  28
                             stream_describeQuery.add(describeQuery4.getTree());
 388  
 
 389  
                             }
 390  28
                             break;
 391  
                         case 4 :
 392  
                             // com\\googlecode\\sparkleg\\Sparql.g:77:64: askQuery
 393  
                             {
 394  120
                             pushFollow(FOLLOW_askQuery_in_query170);
 395  120
                             askQuery5=askQuery();
 396  
 
 397  120
                             state._fsp--;
 398  
 
 399  120
                             stream_askQuery.add(askQuery5.getTree());
 400  
 
 401  
                             }
 402  
                             break;
 403  
 
 404  
                     }
 405  
 
 406  
 
 407  1834
                     pushFollow(FOLLOW_bindingsClause_in_query173);
 408  1834
                     bindingsClause6=bindingsClause();
 409  
 
 410  1834
                     state._fsp--;
 411  
 
 412  1834
                     stream_bindingsClause.add(bindingsClause6.getTree());
 413  
 
 414  1834
                     EOF7=(Token)match(input,EOF,FOLLOW_EOF_in_query175);  
 415  1834
                     stream_EOF.add(EOF7);
 416  
 
 417  
 
 418  
                     // AST REWRITE
 419  
                     // elements: selectQuery, bindingsClause, describeQuery, prologue, constructQuery, askQuery
 420  
                     // token labels: 
 421  
                     // rule labels: retval
 422  
                     // token list labels: 
 423  
                     // rule list labels: 
 424  
                     // wildcard labels: 
 425  1834
                     retval.tree = root_0;
 426  1834
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 427  
 
 428  1834
                     root_0 = (Object)adaptor.nil();
 429  
                     // 77:93: -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )*
 430  
                     {
 431  
                         // com\\googlecode\\sparkleg\\Sparql.g:77:96: ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* )
 432  
                         {
 433  1834
                         Object root_1 = (Object)adaptor.nil();
 434  1834
                         root_1 = (Object)adaptor.becomeRoot(
 435  
                         (Object)adaptor.create(QUERY, "QUERY")
 436  
                         , root_1);
 437  
 
 438  1834
                         adaptor.addChild(root_1, stream_prologue.nextTree());
 439  
 
 440  
                         // com\\googlecode\\sparkleg\\Sparql.g:77:113: ( selectQuery )*
 441  3448
                         while ( stream_selectQuery.hasNext() ) {
 442  1614
                             adaptor.addChild(root_1, stream_selectQuery.nextTree());
 443  
 
 444  
                         }
 445  1834
                         stream_selectQuery.reset();
 446  
 
 447  
                         // com\\googlecode\\sparkleg\\Sparql.g:77:126: ( constructQuery )*
 448  1906
                         while ( stream_constructQuery.hasNext() ) {
 449  72
                             adaptor.addChild(root_1, stream_constructQuery.nextTree());
 450  
 
 451  
                         }
 452  1834
                         stream_constructQuery.reset();
 453  
 
 454  
                         // com\\googlecode\\sparkleg\\Sparql.g:77:142: ( describeQuery )*
 455  1862
                         while ( stream_describeQuery.hasNext() ) {
 456  28
                             adaptor.addChild(root_1, stream_describeQuery.nextTree());
 457  
 
 458  
                         }
 459  1834
                         stream_describeQuery.reset();
 460  
 
 461  
                         // com\\googlecode\\sparkleg\\Sparql.g:77:157: ( askQuery )*
 462  1954
                         while ( stream_askQuery.hasNext() ) {
 463  120
                             adaptor.addChild(root_1, stream_askQuery.nextTree());
 464  
 
 465  
                         }
 466  1834
                         stream_askQuery.reset();
 467  
 
 468  1834
                         adaptor.addChild(root_0, root_1);
 469  
                         }
 470  
 
 471  
                         // com\\googlecode\\sparkleg\\Sparql.g:77:168: ( bindingsClause )*
 472  1860
                         while ( stream_bindingsClause.hasNext() ) {
 473  26
                             adaptor.addChild(root_0, stream_bindingsClause.nextTree());
 474  
 
 475  
                         }
 476  1834
                         stream_bindingsClause.reset();
 477  
 
 478  
                     }
 479  
 
 480  
 
 481  1834
                     retval.tree = root_0;
 482  
 
 483  
                     }
 484  1834
                     break;
 485  
                 case 2 :
 486  
                     // com\\googlecode\\sparkleg\\Sparql.g:78:7: update ( SEMICOLON ( update )? )* EOF
 487  
                     {
 488  124
                     pushFollow(FOLLOW_update_in_query206);
 489  124
                     update8=update();
 490  
 
 491  124
                     state._fsp--;
 492  
 
 493  124
                     stream_update.add(update8.getTree());
 494  
 
 495  
                     // com\\googlecode\\sparkleg\\Sparql.g:78:14: ( SEMICOLON ( update )? )*
 496  
                     loop3:
 497  
                     do {
 498  128
                         int alt3=2;
 499  128
                         switch ( input.LA(1) ) {
 500  
                         case SEMICOLON:
 501  
                             {
 502  4
                             alt3=1;
 503  
                             }
 504  
                             break;
 505  
 
 506  
                         }
 507  
 
 508  128
                         switch (alt3) {
 509  
                             case 1 :
 510  
                                 // com\\googlecode\\sparkleg\\Sparql.g:78:15: SEMICOLON ( update )?
 511  
                                 {
 512  4
                                 SEMICOLON9=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_query209);  
 513  4
                                 stream_SEMICOLON.add(SEMICOLON9);
 514  
 
 515  
 
 516  
                                 // com\\googlecode\\sparkleg\\Sparql.g:78:25: ( update )?
 517  4
                                 int alt2=2;
 518  4
                                 switch ( input.LA(1) ) {
 519  
                                     case ADD:
 520  
                                     case ASK:
 521  
                                     case BASE:
 522  
                                     case CLEAR:
 523  
                                     case CONSTRUCT:
 524  
                                     case COPY:
 525  
                                     case CREATE:
 526  
                                     case DELETE:
 527  
                                     case DESCRIBE:
 528  
                                     case DROP:
 529  
                                     case INSERT:
 530  
                                     case LOAD:
 531  
                                     case MOVE:
 532  
                                     case PREFIX:
 533  
                                     case SELECT:
 534  
                                     case WITH:
 535  
                                         {
 536  4
                                         alt2=1;
 537  
                                         }
 538  
                                         break;
 539  
                                 }
 540  
 
 541  4
                                 switch (alt2) {
 542  
                                     case 1 :
 543  
                                         // com\\googlecode\\sparkleg\\Sparql.g:78:25: update
 544  
                                         {
 545  4
                                         pushFollow(FOLLOW_update_in_query211);
 546  4
                                         update10=update();
 547  
 
 548  4
                                         state._fsp--;
 549  
 
 550  4
                                         stream_update.add(update10.getTree());
 551  
 
 552  
                                         }
 553  
                                         break;
 554  
 
 555  
                                 }
 556  
 
 557  
 
 558  
                                 }
 559  4
                                 break;
 560  
 
 561  
                             default :
 562  124
                                 break loop3;
 563  
                         }
 564  4
                     } while (true);
 565  
 
 566  
 
 567  124
                     EOF11=(Token)match(input,EOF,FOLLOW_EOF_in_query216);  
 568  124
                     stream_EOF.add(EOF11);
 569  
 
 570  
 
 571  
                     // AST REWRITE
 572  
                     // elements: update
 573  
                     // token labels: 
 574  
                     // rule labels: retval
 575  
                     // token list labels: 
 576  
                     // rule list labels: 
 577  
                     // wildcard labels: 
 578  124
                     retval.tree = root_0;
 579  124
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 580  
 
 581  124
                     root_0 = (Object)adaptor.nil();
 582  
                     // 78:39: -> ^( UPDATE ( update )+ )
 583  
                     {
 584  
                         // com\\googlecode\\sparkleg\\Sparql.g:78:42: ^( UPDATE ( update )+ )
 585  
                         {
 586  124
                         Object root_1 = (Object)adaptor.nil();
 587  124
                         root_1 = (Object)adaptor.becomeRoot(
 588  
                         (Object)adaptor.create(UPDATE, "UPDATE")
 589  
                         , root_1);
 590  
 
 591  124
                         if ( !(stream_update.hasNext()) ) {
 592  0
                             throw new RewriteEarlyExitException();
 593  
                         }
 594  252
                         while ( stream_update.hasNext() ) {
 595  128
                             adaptor.addChild(root_1, stream_update.nextTree());
 596  
 
 597  
                         }
 598  124
                         stream_update.reset();
 599  
 
 600  124
                         adaptor.addChild(root_0, root_1);
 601  
                         }
 602  
 
 603  
                     }
 604  
 
 605  
 
 606  124
                     retval.tree = root_0;
 607  
 
 608  
                     }
 609  
                     break;
 610  
 
 611  
             }
 612  1958
             retval.stop = input.LT(-1);
 613  
 
 614  
 
 615  1958
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 616  1958
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 617  
 
 618  
         }
 619  0
         catch (RecognitionException re) {
 620  0
             reportError(re);
 621  0
             recover(input,re);
 622  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 623  
 
 624  
         }
 625  
 
 626  0
         finally {
 627  
                 // do for sure before leaving
 628  1958
         }
 629  1958
         return retval;
 630  
     }
 631  
     // $ANTLR end "query"
 632  
 
 633  
 
 634  1962
     public static class prologue_return extends ParserRuleReturnScope {
 635  
         Object tree;
 636  1962
         public Object getTree() { return tree; }
 637  
     };
 638  
 
 639  
 
 640  
     // $ANTLR start "prologue"
 641  
     // com\\googlecode\\sparkleg\\Sparql.g:81:1: prologue : ( baseDecl | prefixDecl )* -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) ;
 642  
     public final SparqlParser.prologue_return prologue() throws RecognitionException {
 643  1962
         SparqlParser.prologue_return retval = new SparqlParser.prologue_return();
 644  1962
         retval.start = input.LT(1);
 645  
 
 646  
 
 647  1962
         Object root_0 = null;
 648  
 
 649  1962
         SparqlParser.baseDecl_return baseDecl12 =null;
 650  
 
 651  1962
         SparqlParser.prefixDecl_return prefixDecl13 =null;
 652  
 
 653  
 
 654  1962
         RewriteRuleSubtreeStream stream_prefixDecl=new RewriteRuleSubtreeStream(adaptor,"rule prefixDecl");
 655  1962
         RewriteRuleSubtreeStream stream_baseDecl=new RewriteRuleSubtreeStream(adaptor,"rule baseDecl");
 656  
         try {
 657  
             // com\\googlecode\\sparkleg\\Sparql.g:83:5: ( ( baseDecl | prefixDecl )* -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) )
 658  
             // com\\googlecode\\sparkleg\\Sparql.g:83:7: ( baseDecl | prefixDecl )*
 659  
             {
 660  
             // com\\googlecode\\sparkleg\\Sparql.g:83:7: ( baseDecl | prefixDecl )*
 661  
             loop5:
 662  
             do {
 663  4814
                 int alt5=3;
 664  4814
                 switch ( input.LA(1) ) {
 665  
                 case BASE:
 666  
                     {
 667  62
                     alt5=1;
 668  
                     }
 669  62
                     break;
 670  
                 case PREFIX:
 671  
                     {
 672  2790
                     alt5=2;
 673  
                     }
 674  
                     break;
 675  
 
 676  
                 }
 677  
 
 678  4814
                 switch (alt5) {
 679  
                     case 1 :
 680  
                         // com\\googlecode\\sparkleg\\Sparql.g:83:8: baseDecl
 681  
                         {
 682  62
                         pushFollow(FOLLOW_baseDecl_in_prologue249);
 683  62
                         baseDecl12=baseDecl();
 684  
 
 685  62
                         state._fsp--;
 686  
 
 687  62
                         stream_baseDecl.add(baseDecl12.getTree());
 688  
 
 689  
                         }
 690  62
                         break;
 691  
                     case 2 :
 692  
                         // com\\googlecode\\sparkleg\\Sparql.g:83:19: prefixDecl
 693  
                         {
 694  2790
                         pushFollow(FOLLOW_prefixDecl_in_prologue253);
 695  2790
                         prefixDecl13=prefixDecl();
 696  
 
 697  2790
                         state._fsp--;
 698  
 
 699  2790
                         stream_prefixDecl.add(prefixDecl13.getTree());
 700  
 
 701  
                         }
 702  2790
                         break;
 703  
 
 704  
                     default :
 705  1962
                         break loop5;
 706  
                 }
 707  2852
             } while (true);
 708  
 
 709  
 
 710  
             // AST REWRITE
 711  
             // elements: baseDecl, prefixDecl
 712  
             // token labels: 
 713  
             // rule labels: retval
 714  
             // token list labels: 
 715  
             // rule list labels: 
 716  
             // wildcard labels: 
 717  1962
             retval.tree = root_0;
 718  1962
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 719  
 
 720  1962
             root_0 = (Object)adaptor.nil();
 721  
             // 83:32: -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* )
 722  
             {
 723  
                 // com\\googlecode\\sparkleg\\Sparql.g:83:35: ^( PROLOGUE ( baseDecl )* ( prefixDecl )* )
 724  
                 {
 725  1962
                 Object root_1 = (Object)adaptor.nil();
 726  1962
                 root_1 = (Object)adaptor.becomeRoot(
 727  
                 (Object)adaptor.create(PROLOGUE, "PROLOGUE")
 728  
                 , root_1);
 729  
 
 730  
                 // com\\googlecode\\sparkleg\\Sparql.g:83:46: ( baseDecl )*
 731  2024
                 while ( stream_baseDecl.hasNext() ) {
 732  62
                     adaptor.addChild(root_1, stream_baseDecl.nextTree());
 733  
 
 734  
                 }
 735  1962
                 stream_baseDecl.reset();
 736  
 
 737  
                 // com\\googlecode\\sparkleg\\Sparql.g:83:56: ( prefixDecl )*
 738  4752
                 while ( stream_prefixDecl.hasNext() ) {
 739  2790
                     adaptor.addChild(root_1, stream_prefixDecl.nextTree());
 740  
 
 741  
                 }
 742  1962
                 stream_prefixDecl.reset();
 743  
 
 744  1962
                 adaptor.addChild(root_0, root_1);
 745  
                 }
 746  
 
 747  
             }
 748  
 
 749  
 
 750  1962
             retval.tree = root_0;
 751  
 
 752  
             }
 753  
 
 754  1962
             retval.stop = input.LT(-1);
 755  
 
 756  
 
 757  1962
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 758  1962
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 759  
 
 760  
         }
 761  0
         catch (RecognitionException re) {
 762  0
             reportError(re);
 763  0
             recover(input,re);
 764  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 765  
 
 766  
         }
 767  
 
 768  0
         finally {
 769  
                 // do for sure before leaving
 770  1962
         }
 771  1962
         return retval;
 772  
     }
 773  
     // $ANTLR end "prologue"
 774  
 
 775  
 
 776  62
     public static class baseDecl_return extends ParserRuleReturnScope {
 777  
         Object tree;
 778  62
         public Object getTree() { return tree; }
 779  
     };
 780  
 
 781  
 
 782  
     // $ANTLR start "baseDecl"
 783  
     // com\\googlecode\\sparkleg\\Sparql.g:86:1: baseDecl : BASE IRI_REF -> ^( BASE IRI_REF ) ;
 784  
     public final SparqlParser.baseDecl_return baseDecl() throws RecognitionException {
 785  62
         SparqlParser.baseDecl_return retval = new SparqlParser.baseDecl_return();
 786  62
         retval.start = input.LT(1);
 787  
 
 788  
 
 789  62
         Object root_0 = null;
 790  
 
 791  62
         Token BASE14=null;
 792  62
         Token IRI_REF15=null;
 793  
 
 794  62
         Object BASE14_tree=null;
 795  62
         Object IRI_REF15_tree=null;
 796  62
         RewriteRuleTokenStream stream_BASE=new RewriteRuleTokenStream(adaptor,"token BASE");
 797  62
         RewriteRuleTokenStream stream_IRI_REF=new RewriteRuleTokenStream(adaptor,"token IRI_REF");
 798  
 
 799  
         try {
 800  
             // com\\googlecode\\sparkleg\\Sparql.g:87:5: ( BASE IRI_REF -> ^( BASE IRI_REF ) )
 801  
             // com\\googlecode\\sparkleg\\Sparql.g:87:7: BASE IRI_REF
 802  
             {
 803  62
             BASE14=(Token)match(input,BASE,FOLLOW_BASE_in_baseDecl284);  
 804  62
             stream_BASE.add(BASE14);
 805  
 
 806  
 
 807  62
             IRI_REF15=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_baseDecl286);  
 808  62
             stream_IRI_REF.add(IRI_REF15);
 809  
 
 810  
 
 811  
             // AST REWRITE
 812  
             // elements: BASE, IRI_REF
 813  
             // token labels: 
 814  
             // rule labels: retval
 815  
             // token list labels: 
 816  
             // rule list labels: 
 817  
             // wildcard labels: 
 818  62
             retval.tree = root_0;
 819  62
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 820  
 
 821  62
             root_0 = (Object)adaptor.nil();
 822  
             // 87:20: -> ^( BASE IRI_REF )
 823  
             {
 824  
                 // com\\googlecode\\sparkleg\\Sparql.g:87:23: ^( BASE IRI_REF )
 825  
                 {
 826  62
                 Object root_1 = (Object)adaptor.nil();
 827  62
                 root_1 = (Object)adaptor.becomeRoot(
 828  
                 stream_BASE.nextNode()
 829  
                 , root_1);
 830  
 
 831  62
                 adaptor.addChild(root_1, 
 832  
                 stream_IRI_REF.nextNode()
 833  
                 );
 834  
 
 835  62
                 adaptor.addChild(root_0, root_1);
 836  
                 }
 837  
 
 838  
             }
 839  
 
 840  
 
 841  62
             retval.tree = root_0;
 842  
 
 843  
             }
 844  
 
 845  62
             retval.stop = input.LT(-1);
 846  
 
 847  
 
 848  62
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 849  62
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 850  
 
 851  
         }
 852  0
         catch (RecognitionException re) {
 853  0
             reportError(re);
 854  0
             recover(input,re);
 855  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 856  
 
 857  
         }
 858  
 
 859  0
         finally {
 860  
                 // do for sure before leaving
 861  62
         }
 862  62
         return retval;
 863  
     }
 864  
     // $ANTLR end "baseDecl"
 865  
 
 866  
 
 867  2790
     public static class prefixDecl_return extends ParserRuleReturnScope {
 868  
         Object tree;
 869  2790
         public Object getTree() { return tree; }
 870  
     };
 871  
 
 872  
 
 873  
     // $ANTLR start "prefixDecl"
 874  
     // com\\googlecode\\sparkleg\\Sparql.g:90:1: prefixDecl : PREFIX PNAME_NS IRI_REF -> ^( PREFIX PNAME_NS IRI_REF ) ;
 875  
     public final SparqlParser.prefixDecl_return prefixDecl() throws RecognitionException {
 876  2790
         SparqlParser.prefixDecl_return retval = new SparqlParser.prefixDecl_return();
 877  2790
         retval.start = input.LT(1);
 878  
 
 879  
 
 880  2790
         Object root_0 = null;
 881  
 
 882  2790
         Token PREFIX16=null;
 883  2790
         Token PNAME_NS17=null;
 884  2790
         Token IRI_REF18=null;
 885  
 
 886  2790
         Object PREFIX16_tree=null;
 887  2790
         Object PNAME_NS17_tree=null;
 888  2790
         Object IRI_REF18_tree=null;
 889  2790
         RewriteRuleTokenStream stream_PREFIX=new RewriteRuleTokenStream(adaptor,"token PREFIX");
 890  2790
         RewriteRuleTokenStream stream_PNAME_NS=new RewriteRuleTokenStream(adaptor,"token PNAME_NS");
 891  2790
         RewriteRuleTokenStream stream_IRI_REF=new RewriteRuleTokenStream(adaptor,"token IRI_REF");
 892  
 
 893  
         try {
 894  
             // com\\googlecode\\sparkleg\\Sparql.g:91:5: ( PREFIX PNAME_NS IRI_REF -> ^( PREFIX PNAME_NS IRI_REF ) )
 895  
             // com\\googlecode\\sparkleg\\Sparql.g:91:7: PREFIX PNAME_NS IRI_REF
 896  
             {
 897  2790
             PREFIX16=(Token)match(input,PREFIX,FOLLOW_PREFIX_in_prefixDecl312);  
 898  2790
             stream_PREFIX.add(PREFIX16);
 899  
 
 900  
 
 901  2790
             PNAME_NS17=(Token)match(input,PNAME_NS,FOLLOW_PNAME_NS_in_prefixDecl314);  
 902  2790
             stream_PNAME_NS.add(PNAME_NS17);
 903  
 
 904  
 
 905  2790
             IRI_REF18=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_prefixDecl316);  
 906  2790
             stream_IRI_REF.add(IRI_REF18);
 907  
 
 908  
 
 909  
             // AST REWRITE
 910  
             // elements: PREFIX, IRI_REF, PNAME_NS
 911  
             // token labels: 
 912  
             // rule labels: retval
 913  
             // token list labels: 
 914  
             // rule list labels: 
 915  
             // wildcard labels: 
 916  2790
             retval.tree = root_0;
 917  2790
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 918  
 
 919  2790
             root_0 = (Object)adaptor.nil();
 920  
             // 91:31: -> ^( PREFIX PNAME_NS IRI_REF )
 921  
             {
 922  
                 // com\\googlecode\\sparkleg\\Sparql.g:91:34: ^( PREFIX PNAME_NS IRI_REF )
 923  
                 {
 924  2790
                 Object root_1 = (Object)adaptor.nil();
 925  2790
                 root_1 = (Object)adaptor.becomeRoot(
 926  
                 stream_PREFIX.nextNode()
 927  
                 , root_1);
 928  
 
 929  2790
                 adaptor.addChild(root_1, 
 930  
                 stream_PNAME_NS.nextNode()
 931  
                 );
 932  
 
 933  2790
                 adaptor.addChild(root_1, 
 934  
                 stream_IRI_REF.nextNode()
 935  
                 );
 936  
 
 937  2790
                 adaptor.addChild(root_0, root_1);
 938  
                 }
 939  
 
 940  
             }
 941  
 
 942  
 
 943  2790
             retval.tree = root_0;
 944  
 
 945  
             }
 946  
 
 947  2790
             retval.stop = input.LT(-1);
 948  
 
 949  
 
 950  2790
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 951  2790
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 952  
 
 953  
         }
 954  0
         catch (RecognitionException re) {
 955  0
             reportError(re);
 956  0
             recover(input,re);
 957  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 958  
 
 959  
         }
 960  
 
 961  0
         finally {
 962  
                 // do for sure before leaving
 963  2790
         }
 964  2790
         return retval;
 965  
     }
 966  
     // $ANTLR end "prefixDecl"
 967  
 
 968  
 
 969  1614
     public static class selectQuery_return extends ParserRuleReturnScope {
 970  
         Object tree;
 971  1614
         public Object getTree() { return tree; }
 972  
     };
 973  
 
 974  
 
 975  
     // $ANTLR start "selectQuery"
 976  
     // com\\googlecode\\sparkleg\\Sparql.g:94:1: selectQuery : selectClause ( datasetClause )* whereClause solutionModifier -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* ) ;
 977  
     public final SparqlParser.selectQuery_return selectQuery() throws RecognitionException {
 978  1614
         SparqlParser.selectQuery_return retval = new SparqlParser.selectQuery_return();
 979  1614
         retval.start = input.LT(1);
 980  
 
 981  
 
 982  1614
         Object root_0 = null;
 983  
 
 984  1614
         SparqlParser.selectClause_return selectClause19 =null;
 985  
 
 986  1614
         SparqlParser.datasetClause_return datasetClause20 =null;
 987  
 
 988  1614
         SparqlParser.whereClause_return whereClause21 =null;
 989  
 
 990  1614
         SparqlParser.solutionModifier_return solutionModifier22 =null;
 991  
 
 992  
 
 993  1614
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 994  1614
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 995  1614
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 996  1614
         RewriteRuleSubtreeStream stream_selectClause=new RewriteRuleSubtreeStream(adaptor,"rule selectClause");
 997  
         try {
 998  
             // com\\googlecode\\sparkleg\\Sparql.g:95:5: ( selectClause ( datasetClause )* whereClause solutionModifier -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* ) )
 999  
             // com\\googlecode\\sparkleg\\Sparql.g:95:7: selectClause ( datasetClause )* whereClause solutionModifier
 1000  
             {
 1001  1614
             pushFollow(FOLLOW_selectClause_in_selectQuery343);
 1002  1614
             selectClause19=selectClause();
 1003  
 
 1004  1614
             state._fsp--;
 1005  
 
 1006  1614
             stream_selectClause.add(selectClause19.getTree());
 1007  
 
 1008  
             // com\\googlecode\\sparkleg\\Sparql.g:95:20: ( datasetClause )*
 1009  
             loop6:
 1010  
             do {
 1011  1772
                 int alt6=2;
 1012  1772
                 switch ( input.LA(1) ) {
 1013  
                 case FROM:
 1014  
                     {
 1015  158
                     alt6=1;
 1016  
                     }
 1017  
                     break;
 1018  
 
 1019  
                 }
 1020  
 
 1021  1772
                 switch (alt6) {
 1022  
                     case 1 :
 1023  
                         // com\\googlecode\\sparkleg\\Sparql.g:95:20: datasetClause
 1024  
                         {
 1025  158
                         pushFollow(FOLLOW_datasetClause_in_selectQuery345);
 1026  158
                         datasetClause20=datasetClause();
 1027  
 
 1028  158
                         state._fsp--;
 1029  
 
 1030  158
                         stream_datasetClause.add(datasetClause20.getTree());
 1031  
 
 1032  
                         }
 1033  158
                         break;
 1034  
 
 1035  
                     default :
 1036  1614
                         break loop6;
 1037  
                 }
 1038  158
             } while (true);
 1039  
 
 1040  
 
 1041  1614
             pushFollow(FOLLOW_whereClause_in_selectQuery348);
 1042  1614
             whereClause21=whereClause();
 1043  
 
 1044  1614
             state._fsp--;
 1045  
 
 1046  1614
             stream_whereClause.add(whereClause21.getTree());
 1047  
 
 1048  1614
             pushFollow(FOLLOW_solutionModifier_in_selectQuery350);
 1049  1614
             solutionModifier22=solutionModifier();
 1050  
 
 1051  1614
             state._fsp--;
 1052  
 
 1053  1614
             stream_solutionModifier.add(solutionModifier22.getTree());
 1054  
 
 1055  
             // AST REWRITE
 1056  
             // elements: solutionModifier, whereClause, datasetClause, selectClause
 1057  
             // token labels: 
 1058  
             // rule labels: retval
 1059  
             // token list labels: 
 1060  
             // rule list labels: 
 1061  
             // wildcard labels: 
 1062  1614
             retval.tree = root_0;
 1063  1614
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1064  
 
 1065  1614
             root_0 = (Object)adaptor.nil();
 1066  
             // 95:64: -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1067  
             {
 1068  
                 // com\\googlecode\\sparkleg\\Sparql.g:95:67: ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1069  
                 {
 1070  1614
                 Object root_1 = (Object)adaptor.nil();
 1071  1614
                 root_1 = (Object)adaptor.becomeRoot(
 1072  
                 (Object)adaptor.create(SELECT, "SELECT")
 1073  
                 , root_1);
 1074  
 
 1075  1614
                 adaptor.addChild(root_1, stream_selectClause.nextTree());
 1076  
 
 1077  
                 // com\\googlecode\\sparkleg\\Sparql.g:95:89: ( datasetClause )*
 1078  1772
                 while ( stream_datasetClause.hasNext() ) {
 1079  158
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 1080  
 
 1081  
                 }
 1082  1614
                 stream_datasetClause.reset();
 1083  
 
 1084  
                 // com\\googlecode\\sparkleg\\Sparql.g:95:104: ( whereClause )*
 1085  3228
                 while ( stream_whereClause.hasNext() ) {
 1086  1614
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 1087  
 
 1088  
                 }
 1089  1614
                 stream_whereClause.reset();
 1090  
 
 1091  
                 // com\\googlecode\\sparkleg\\Sparql.g:95:117: ( solutionModifier )*
 1092  1802
                 while ( stream_solutionModifier.hasNext() ) {
 1093  188
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 1094  
 
 1095  
                 }
 1096  1614
                 stream_solutionModifier.reset();
 1097  
 
 1098  1614
                 adaptor.addChild(root_0, root_1);
 1099  
                 }
 1100  
 
 1101  
             }
 1102  
 
 1103  
 
 1104  1614
             retval.tree = root_0;
 1105  
 
 1106  
             }
 1107  
 
 1108  1614
             retval.stop = input.LT(-1);
 1109  
 
 1110  
 
 1111  1614
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1112  1614
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1113  
 
 1114  
         }
 1115  0
         catch (RecognitionException re) {
 1116  0
             reportError(re);
 1117  0
             recover(input,re);
 1118  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1119  
 
 1120  
         }
 1121  
 
 1122  0
         finally {
 1123  
                 // do for sure before leaving
 1124  1614
         }
 1125  1614
         return retval;
 1126  
     }
 1127  
     // $ANTLR end "selectQuery"
 1128  
 
 1129  
 
 1130  46
     public static class subSelect_return extends ParserRuleReturnScope {
 1131  
         Object tree;
 1132  46
         public Object getTree() { return tree; }
 1133  
     };
 1134  
 
 1135  
 
 1136  
     // $ANTLR start "subSelect"
 1137  
     // com\\googlecode\\sparkleg\\Sparql.g:98:1: subSelect : selectClause whereClause solutionModifier -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* ) ;
 1138  
     public final SparqlParser.subSelect_return subSelect() throws RecognitionException {
 1139  46
         SparqlParser.subSelect_return retval = new SparqlParser.subSelect_return();
 1140  46
         retval.start = input.LT(1);
 1141  
 
 1142  
 
 1143  46
         Object root_0 = null;
 1144  
 
 1145  46
         SparqlParser.selectClause_return selectClause23 =null;
 1146  
 
 1147  46
         SparqlParser.whereClause_return whereClause24 =null;
 1148  
 
 1149  46
         SparqlParser.solutionModifier_return solutionModifier25 =null;
 1150  
 
 1151  
 
 1152  46
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1153  46
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1154  46
         RewriteRuleSubtreeStream stream_selectClause=new RewriteRuleSubtreeStream(adaptor,"rule selectClause");
 1155  
         try {
 1156  
             // com\\googlecode\\sparkleg\\Sparql.g:99:5: ( selectClause whereClause solutionModifier -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* ) )
 1157  
             // com\\googlecode\\sparkleg\\Sparql.g:99:7: selectClause whereClause solutionModifier
 1158  
             {
 1159  46
             pushFollow(FOLLOW_selectClause_in_subSelect384);
 1160  46
             selectClause23=selectClause();
 1161  
 
 1162  46
             state._fsp--;
 1163  
 
 1164  46
             stream_selectClause.add(selectClause23.getTree());
 1165  
 
 1166  46
             pushFollow(FOLLOW_whereClause_in_subSelect386);
 1167  46
             whereClause24=whereClause();
 1168  
 
 1169  46
             state._fsp--;
 1170  
 
 1171  46
             stream_whereClause.add(whereClause24.getTree());
 1172  
 
 1173  46
             pushFollow(FOLLOW_solutionModifier_in_subSelect388);
 1174  46
             solutionModifier25=solutionModifier();
 1175  
 
 1176  46
             state._fsp--;
 1177  
 
 1178  46
             stream_solutionModifier.add(solutionModifier25.getTree());
 1179  
 
 1180  
             // AST REWRITE
 1181  
             // elements: whereClause, selectClause, solutionModifier
 1182  
             // token labels: 
 1183  
             // rule labels: retval
 1184  
             // token list labels: 
 1185  
             // rule list labels: 
 1186  
             // wildcard labels: 
 1187  46
             retval.tree = root_0;
 1188  46
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1189  
 
 1190  46
             root_0 = (Object)adaptor.nil();
 1191  
             // 99:49: -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* )
 1192  
             {
 1193  
                 // com\\googlecode\\sparkleg\\Sparql.g:99:52: ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* )
 1194  
                 {
 1195  46
                 Object root_1 = (Object)adaptor.nil();
 1196  46
                 root_1 = (Object)adaptor.becomeRoot(
 1197  
                 (Object)adaptor.create(SUBSELECT, "SUBSELECT")
 1198  
                 , root_1);
 1199  
 
 1200  46
                 adaptor.addChild(root_1, stream_selectClause.nextTree());
 1201  
 
 1202  
                 // com\\googlecode\\sparkleg\\Sparql.g:99:77: ( whereClause )*
 1203  92
                 while ( stream_whereClause.hasNext() ) {
 1204  46
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 1205  
 
 1206  
                 }
 1207  46
                 stream_whereClause.reset();
 1208  
 
 1209  
                 // com\\googlecode\\sparkleg\\Sparql.g:99:90: ( solutionModifier )*
 1210  56
                 while ( stream_solutionModifier.hasNext() ) {
 1211  10
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 1212  
 
 1213  
                 }
 1214  46
                 stream_solutionModifier.reset();
 1215  
 
 1216  46
                 adaptor.addChild(root_0, root_1);
 1217  
                 }
 1218  
 
 1219  
             }
 1220  
 
 1221  
 
 1222  46
             retval.tree = root_0;
 1223  
 
 1224  
             }
 1225  
 
 1226  46
             retval.stop = input.LT(-1);
 1227  
 
 1228  
 
 1229  46
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1230  46
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1231  
 
 1232  
         }
 1233  0
         catch (RecognitionException re) {
 1234  0
             reportError(re);
 1235  0
             recover(input,re);
 1236  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1237  
 
 1238  
         }
 1239  
 
 1240  0
         finally {
 1241  
                 // do for sure before leaving
 1242  46
         }
 1243  46
         return retval;
 1244  
     }
 1245  
     // $ANTLR end "subSelect"
 1246  
 
 1247  
 
 1248  1660
     public static class selectClause_return extends ParserRuleReturnScope {
 1249  
         Object tree;
 1250  1660
         public Object getTree() { return tree; }
 1251  
     };
 1252  
 
 1253  
 
 1254  
     // $ANTLR start "selectClause"
 1255  
     // com\\googlecode\\sparkleg\\Sparql.g:102:1: selectClause : ( SELECT ( DISTINCT | REDUCED )? ASTERISK -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK ) | SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+ -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* ) );
 1256  
     public final SparqlParser.selectClause_return selectClause() throws RecognitionException {
 1257  1660
         SparqlParser.selectClause_return retval = new SparqlParser.selectClause_return();
 1258  1660
         retval.start = input.LT(1);
 1259  
 
 1260  
 
 1261  1660
         Object root_0 = null;
 1262  
 
 1263  1660
         Token SELECT26=null;
 1264  1660
         Token DISTINCT27=null;
 1265  1660
         Token REDUCED28=null;
 1266  1660
         Token ASTERISK29=null;
 1267  1660
         Token SELECT30=null;
 1268  1660
         Token DISTINCT31=null;
 1269  1660
         Token REDUCED32=null;
 1270  1660
         List list_v=null;
 1271  1660
         RuleReturnScope v = null;
 1272  1660
         Object SELECT26_tree=null;
 1273  1660
         Object DISTINCT27_tree=null;
 1274  1660
         Object REDUCED28_tree=null;
 1275  1660
         Object ASTERISK29_tree=null;
 1276  1660
         Object SELECT30_tree=null;
 1277  1660
         Object DISTINCT31_tree=null;
 1278  1660
         Object REDUCED32_tree=null;
 1279  1660
         RewriteRuleTokenStream stream_SELECT=new RewriteRuleTokenStream(adaptor,"token SELECT");
 1280  1660
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 1281  1660
         RewriteRuleTokenStream stream_REDUCED=new RewriteRuleTokenStream(adaptor,"token REDUCED");
 1282  1660
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 1283  1660
         RewriteRuleSubtreeStream stream_selectVariables=new RewriteRuleSubtreeStream(adaptor,"rule selectVariables");
 1284  
         try {
 1285  
             // com\\googlecode\\sparkleg\\Sparql.g:103:5: ( SELECT ( DISTINCT | REDUCED )? ASTERISK -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK ) | SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+ -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* ) )
 1286  1660
             int alt10=2;
 1287  1660
             switch ( input.LA(1) ) {
 1288  
             case SELECT:
 1289  
                 {
 1290  1660
                 switch ( input.LA(2) ) {
 1291  
                 case DISTINCT:
 1292  
                     {
 1293  44
                     switch ( input.LA(3) ) {
 1294  
                     case ASTERISK:
 1295  
                         {
 1296  2
                         alt10=1;
 1297  
                         }
 1298  2
                         break;
 1299  
                     case OPEN_BRACE:
 1300  
                     case VAR1:
 1301  
                     case VAR2:
 1302  
                         {
 1303  42
                         alt10=2;
 1304  
                         }
 1305  42
                         break;
 1306  
                     default:
 1307  0
                         NoViableAltException nvae =
 1308  
                             new NoViableAltException("", 10, 2, input);
 1309  
 
 1310  0
                         throw nvae;
 1311  
 
 1312  
                     }
 1313  
 
 1314  
                     }
 1315  44
                     break;
 1316  
                 case REDUCED:
 1317  
                     {
 1318  14
                     switch ( input.LA(3) ) {
 1319  
                     case ASTERISK:
 1320  
                         {
 1321  4
                         alt10=1;
 1322  
                         }
 1323  4
                         break;
 1324  
                     case OPEN_BRACE:
 1325  
                     case VAR1:
 1326  
                     case VAR2:
 1327  
                         {
 1328  10
                         alt10=2;
 1329  
                         }
 1330  10
                         break;
 1331  
                     default:
 1332  0
                         NoViableAltException nvae =
 1333  
                             new NoViableAltException("", 10, 3, input);
 1334  
 
 1335  0
                         throw nvae;
 1336  
 
 1337  
                     }
 1338  
 
 1339  
                     }
 1340  14
                     break;
 1341  
                 case ASTERISK:
 1342  
                     {
 1343  680
                     alt10=1;
 1344  
                     }
 1345  680
                     break;
 1346  
                 case OPEN_BRACE:
 1347  
                 case VAR1:
 1348  
                 case VAR2:
 1349  
                     {
 1350  922
                     alt10=2;
 1351  
                     }
 1352  922
                     break;
 1353  
                 default:
 1354  0
                     NoViableAltException nvae =
 1355  
                         new NoViableAltException("", 10, 1, input);
 1356  
 
 1357  0
                     throw nvae;
 1358  
 
 1359  
                 }
 1360  
 
 1361  
                 }
 1362  1660
                 break;
 1363  
             default:
 1364  0
                 NoViableAltException nvae =
 1365  
                     new NoViableAltException("", 10, 0, input);
 1366  
 
 1367  0
                 throw nvae;
 1368  
 
 1369  
             }
 1370  
 
 1371  1660
             switch (alt10) {
 1372  
                 case 1 :
 1373  
                     // com\\googlecode\\sparkleg\\Sparql.g:103:7: SELECT ( DISTINCT | REDUCED )? ASTERISK
 1374  
                     {
 1375  686
                     SELECT26=(Token)match(input,SELECT,FOLLOW_SELECT_in_selectClause424);  
 1376  686
                     stream_SELECT.add(SELECT26);
 1377  
 
 1378  
 
 1379  
                     // com\\googlecode\\sparkleg\\Sparql.g:103:14: ( DISTINCT | REDUCED )?
 1380  686
                     int alt7=3;
 1381  686
                     switch ( input.LA(1) ) {
 1382  
                         case DISTINCT:
 1383  
                             {
 1384  2
                             alt7=1;
 1385  
                             }
 1386  2
                             break;
 1387  
                         case REDUCED:
 1388  
                             {
 1389  4
                             alt7=2;
 1390  
                             }
 1391  
                             break;
 1392  
                     }
 1393  
 
 1394  686
                     switch (alt7) {
 1395  
                         case 1 :
 1396  
                             // com\\googlecode\\sparkleg\\Sparql.g:103:15: DISTINCT
 1397  
                             {
 1398  2
                             DISTINCT27=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause427);  
 1399  2
                             stream_DISTINCT.add(DISTINCT27);
 1400  
 
 1401  
 
 1402  
                             }
 1403  2
                             break;
 1404  
                         case 2 :
 1405  
                             // com\\googlecode\\sparkleg\\Sparql.g:103:26: REDUCED
 1406  
                             {
 1407  4
                             REDUCED28=(Token)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause431);  
 1408  4
                             stream_REDUCED.add(REDUCED28);
 1409  
 
 1410  
 
 1411  
                             }
 1412  
                             break;
 1413  
 
 1414  
                     }
 1415  
 
 1416  
 
 1417  686
                     ASTERISK29=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_selectClause435);  
 1418  686
                     stream_ASTERISK.add(ASTERISK29);
 1419  
 
 1420  
 
 1421  
                     // AST REWRITE
 1422  
                     // elements: DISTINCT, REDUCED, ASTERISK
 1423  
                     // token labels: 
 1424  
                     // rule labels: retval
 1425  
                     // token list labels: 
 1426  
                     // rule list labels: 
 1427  
                     // wildcard labels: 
 1428  686
                     retval.tree = root_0;
 1429  686
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1430  
 
 1431  686
                     root_0 = (Object)adaptor.nil();
 1432  
                     // 103:45: -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK )
 1433  
                     {
 1434  
                         // com\\googlecode\\sparkleg\\Sparql.g:103:48: ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK )
 1435  
                         {
 1436  686
                         Object root_1 = (Object)adaptor.nil();
 1437  686
                         root_1 = (Object)adaptor.becomeRoot(
 1438  
                         (Object)adaptor.create(SELECT_CLAUSE, "SELECT_CLAUSE")
 1439  
                         , root_1);
 1440  
 
 1441  
                         // com\\googlecode\\sparkleg\\Sparql.g:103:64: ( DISTINCT )*
 1442  688
                         while ( stream_DISTINCT.hasNext() ) {
 1443  2
                             adaptor.addChild(root_1, 
 1444  
                             stream_DISTINCT.nextNode()
 1445  
                             );
 1446  
 
 1447  
                         }
 1448  686
                         stream_DISTINCT.reset();
 1449  
 
 1450  
                         // com\\googlecode\\sparkleg\\Sparql.g:103:74: ( REDUCED )*
 1451  690
                         while ( stream_REDUCED.hasNext() ) {
 1452  4
                             adaptor.addChild(root_1, 
 1453  
                             stream_REDUCED.nextNode()
 1454  
                             );
 1455  
 
 1456  
                         }
 1457  686
                         stream_REDUCED.reset();
 1458  
 
 1459  686
                         adaptor.addChild(root_1, 
 1460  
                         stream_ASTERISK.nextNode()
 1461  
                         );
 1462  
 
 1463  686
                         adaptor.addChild(root_0, root_1);
 1464  
                         }
 1465  
 
 1466  
                     }
 1467  
 
 1468  
 
 1469  686
                     retval.tree = root_0;
 1470  
 
 1471  
                     }
 1472  686
                     break;
 1473  
                 case 2 :
 1474  
                     // com\\googlecode\\sparkleg\\Sparql.g:104:7: SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+
 1475  
                     {
 1476  974
                     SELECT30=(Token)match(input,SELECT,FOLLOW_SELECT_in_selectClause457);  
 1477  974
                     stream_SELECT.add(SELECT30);
 1478  
 
 1479  
 
 1480  
                     // com\\googlecode\\sparkleg\\Sparql.g:104:14: ( DISTINCT | REDUCED )?
 1481  974
                     int alt8=3;
 1482  974
                     switch ( input.LA(1) ) {
 1483  
                         case DISTINCT:
 1484  
                             {
 1485  42
                             alt8=1;
 1486  
                             }
 1487  42
                             break;
 1488  
                         case REDUCED:
 1489  
                             {
 1490  10
                             alt8=2;
 1491  
                             }
 1492  
                             break;
 1493  
                     }
 1494  
 
 1495  974
                     switch (alt8) {
 1496  
                         case 1 :
 1497  
                             // com\\googlecode\\sparkleg\\Sparql.g:104:15: DISTINCT
 1498  
                             {
 1499  42
                             DISTINCT31=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause460);  
 1500  42
                             stream_DISTINCT.add(DISTINCT31);
 1501  
 
 1502  
 
 1503  
                             }
 1504  42
                             break;
 1505  
                         case 2 :
 1506  
                             // com\\googlecode\\sparkleg\\Sparql.g:104:26: REDUCED
 1507  
                             {
 1508  10
                             REDUCED32=(Token)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause464);  
 1509  10
                             stream_REDUCED.add(REDUCED32);
 1510  
 
 1511  
 
 1512  
                             }
 1513  
                             break;
 1514  
 
 1515  
                     }
 1516  
 
 1517  
 
 1518  
                     // com\\googlecode\\sparkleg\\Sparql.g:104:36: (v+= selectVariables )+
 1519  974
                     int cnt9=0;
 1520  
                     loop9:
 1521  
                     do {
 1522  2630
                         int alt9=2;
 1523  2630
                         switch ( input.LA(1) ) {
 1524  
                         case OPEN_BRACE:
 1525  
                         case VAR1:
 1526  
                         case VAR2:
 1527  
                             {
 1528  1656
                             alt9=1;
 1529  
                             }
 1530  
                             break;
 1531  
 
 1532  
                         }
 1533  
 
 1534  2630
                         switch (alt9) {
 1535  
                             case 1 :
 1536  
                                 // com\\googlecode\\sparkleg\\Sparql.g:104:37: v+= selectVariables
 1537  
                                 {
 1538  1656
                                 pushFollow(FOLLOW_selectVariables_in_selectClause471);
 1539  1656
                                 v=selectVariables();
 1540  
 
 1541  1656
                                 state._fsp--;
 1542  
 
 1543  1656
                                 stream_selectVariables.add(v.getTree());
 1544  1656
                                 if (list_v==null) list_v=new ArrayList();
 1545  1656
                                 list_v.add(v.getTree());
 1546  
 
 1547  
 
 1548  
                                 }
 1549  1656
                                 break;
 1550  
 
 1551  
                             default :
 1552  974
                                 if ( cnt9 >= 1 ) break loop9;
 1553  0
                                 EarlyExitException eee =
 1554  
                                     new EarlyExitException(9, input);
 1555  0
                                 throw eee;
 1556  
                         }
 1557  1656
                         cnt9++;
 1558  1656
                     } while (true);
 1559  
 
 1560  
 
 1561  
                     // AST REWRITE
 1562  
                     // elements: REDUCED, DISTINCT, v
 1563  
                     // token labels: 
 1564  
                     // rule labels: retval
 1565  
                     // token list labels: 
 1566  
                     // rule list labels: v
 1567  
                     // wildcard labels: 
 1568  974
                     retval.tree = root_0;
 1569  974
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1570  974
                     RewriteRuleSubtreeStream stream_v=new RewriteRuleSubtreeStream(adaptor,"token v",list_v);
 1571  974
                     root_0 = (Object)adaptor.nil();
 1572  
                     // 104:58: -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* )
 1573  
                     {
 1574  
                         // com\\googlecode\\sparkleg\\Sparql.g:104:61: ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* )
 1575  
                         {
 1576  974
                         Object root_1 = (Object)adaptor.nil();
 1577  974
                         root_1 = (Object)adaptor.becomeRoot(
 1578  
                         (Object)adaptor.create(SELECT_CLAUSE, "SELECT_CLAUSE")
 1579  
                         , root_1);
 1580  
 
 1581  
                         // com\\googlecode\\sparkleg\\Sparql.g:104:77: ( DISTINCT )*
 1582  1016
                         while ( stream_DISTINCT.hasNext() ) {
 1583  42
                             adaptor.addChild(root_1, 
 1584  
                             stream_DISTINCT.nextNode()
 1585  
                             );
 1586  
 
 1587  
                         }
 1588  974
                         stream_DISTINCT.reset();
 1589  
 
 1590  
                         // com\\googlecode\\sparkleg\\Sparql.g:104:87: ( REDUCED )*
 1591  984
                         while ( stream_REDUCED.hasNext() ) {
 1592  10
                             adaptor.addChild(root_1, 
 1593  
                             stream_REDUCED.nextNode()
 1594  
                             );
 1595  
 
 1596  
                         }
 1597  974
                         stream_REDUCED.reset();
 1598  
 
 1599  
                         // com\\googlecode\\sparkleg\\Sparql.g:104:97: ( $v)*
 1600  2630
                         while ( stream_v.hasNext() ) {
 1601  1656
                             adaptor.addChild(root_1, stream_v.nextTree());
 1602  
 
 1603  
                         }
 1604  974
                         stream_v.reset();
 1605  
 
 1606  974
                         adaptor.addChild(root_0, root_1);
 1607  
                         }
 1608  
 
 1609  
                     }
 1610  
 
 1611  
 
 1612  974
                     retval.tree = root_0;
 1613  
 
 1614  
                     }
 1615  
                     break;
 1616  
 
 1617  
             }
 1618  1660
             retval.stop = input.LT(-1);
 1619  
 
 1620  
 
 1621  1660
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1622  1660
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1623  
 
 1624  
         }
 1625  0
         catch (RecognitionException re) {
 1626  0
             reportError(re);
 1627  0
             recover(input,re);
 1628  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1629  
 
 1630  
         }
 1631  
 
 1632  0
         finally {
 1633  
                 // do for sure before leaving
 1634  1660
         }
 1635  1660
         return retval;
 1636  
     }
 1637  
     // $ANTLR end "selectClause"
 1638  
 
 1639  
 
 1640  1656
     public static class selectVariables_return extends ParserRuleReturnScope {
 1641  
         Object tree;
 1642  3312
         public Object getTree() { return tree; }
 1643  
     };
 1644  
 
 1645  
 
 1646  
     // $ANTLR start "selectVariables"
 1647  
     // com\\googlecode\\sparkleg\\Sparql.g:107:1: selectVariables : ( var -> ^( VAR var ) | OPEN_BRACE expression AS var CLOSE_BRACE -> ^( AS expression var ) );
 1648  
     public final SparqlParser.selectVariables_return selectVariables() throws RecognitionException {
 1649  1656
         SparqlParser.selectVariables_return retval = new SparqlParser.selectVariables_return();
 1650  1656
         retval.start = input.LT(1);
 1651  
 
 1652  
 
 1653  1656
         Object root_0 = null;
 1654  
 
 1655  1656
         Token OPEN_BRACE34=null;
 1656  1656
         Token AS36=null;
 1657  1656
         Token CLOSE_BRACE38=null;
 1658  1656
         SparqlParser.var_return var33 =null;
 1659  
 
 1660  1656
         SparqlParser.expression_return expression35 =null;
 1661  
 
 1662  1656
         SparqlParser.var_return var37 =null;
 1663  
 
 1664  
 
 1665  1656
         Object OPEN_BRACE34_tree=null;
 1666  1656
         Object AS36_tree=null;
 1667  1656
         Object CLOSE_BRACE38_tree=null;
 1668  1656
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 1669  1656
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 1670  1656
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 1671  1656
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 1672  1656
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 1673  
         try {
 1674  
             // com\\googlecode\\sparkleg\\Sparql.g:108:5: ( var -> ^( VAR var ) | OPEN_BRACE expression AS var CLOSE_BRACE -> ^( AS expression var ) )
 1675  1656
             int alt11=2;
 1676  1656
             switch ( input.LA(1) ) {
 1677  
             case VAR1:
 1678  
             case VAR2:
 1679  
                 {
 1680  1406
                 alt11=1;
 1681  
                 }
 1682  1406
                 break;
 1683  
             case OPEN_BRACE:
 1684  
                 {
 1685  250
                 alt11=2;
 1686  
                 }
 1687  250
                 break;
 1688  
             default:
 1689  0
                 NoViableAltException nvae =
 1690  
                     new NoViableAltException("", 11, 0, input);
 1691  
 
 1692  0
                 throw nvae;
 1693  
 
 1694  
             }
 1695  
 
 1696  1656
             switch (alt11) {
 1697  
                 case 1 :
 1698  
                     // com\\googlecode\\sparkleg\\Sparql.g:108:7: var
 1699  
                     {
 1700  1406
                     pushFollow(FOLLOW_var_in_selectVariables506);
 1701  1406
                     var33=var();
 1702  
 
 1703  1406
                     state._fsp--;
 1704  
 
 1705  1406
                     stream_var.add(var33.getTree());
 1706  
 
 1707  
                     // AST REWRITE
 1708  
                     // elements: var
 1709  
                     // token labels: 
 1710  
                     // rule labels: retval
 1711  
                     // token list labels: 
 1712  
                     // rule list labels: 
 1713  
                     // wildcard labels: 
 1714  1406
                     retval.tree = root_0;
 1715  1406
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1716  
 
 1717  1406
                     root_0 = (Object)adaptor.nil();
 1718  
                     // 108:11: -> ^( VAR var )
 1719  
                     {
 1720  
                         // com\\googlecode\\sparkleg\\Sparql.g:108:14: ^( VAR var )
 1721  
                         {
 1722  1406
                         Object root_1 = (Object)adaptor.nil();
 1723  1406
                         root_1 = (Object)adaptor.becomeRoot(
 1724  
                         (Object)adaptor.create(VAR, "VAR")
 1725  
                         , root_1);
 1726  
 
 1727  1406
                         adaptor.addChild(root_1, stream_var.nextTree());
 1728  
 
 1729  1406
                         adaptor.addChild(root_0, root_1);
 1730  
                         }
 1731  
 
 1732  
                     }
 1733  
 
 1734  
 
 1735  1406
                     retval.tree = root_0;
 1736  
 
 1737  
                     }
 1738  1406
                     break;
 1739  
                 case 2 :
 1740  
                     // com\\googlecode\\sparkleg\\Sparql.g:109:7: OPEN_BRACE expression AS var CLOSE_BRACE
 1741  
                     {
 1742  250
                     OPEN_BRACE34=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_selectVariables523);  
 1743  250
                     stream_OPEN_BRACE.add(OPEN_BRACE34);
 1744  
 
 1745  
 
 1746  250
                     pushFollow(FOLLOW_expression_in_selectVariables525);
 1747  250
                     expression35=expression();
 1748  
 
 1749  250
                     state._fsp--;
 1750  
 
 1751  250
                     stream_expression.add(expression35.getTree());
 1752  
 
 1753  250
                     AS36=(Token)match(input,AS,FOLLOW_AS_in_selectVariables527);  
 1754  250
                     stream_AS.add(AS36);
 1755  
 
 1756  
 
 1757  250
                     pushFollow(FOLLOW_var_in_selectVariables529);
 1758  250
                     var37=var();
 1759  
 
 1760  250
                     state._fsp--;
 1761  
 
 1762  250
                     stream_var.add(var37.getTree());
 1763  
 
 1764  250
                     CLOSE_BRACE38=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_selectVariables531);  
 1765  250
                     stream_CLOSE_BRACE.add(CLOSE_BRACE38);
 1766  
 
 1767  
 
 1768  
                     // AST REWRITE
 1769  
                     // elements: expression, AS, var
 1770  
                     // token labels: 
 1771  
                     // rule labels: retval
 1772  
                     // token list labels: 
 1773  
                     // rule list labels: 
 1774  
                     // wildcard labels: 
 1775  250
                     retval.tree = root_0;
 1776  250
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1777  
 
 1778  250
                     root_0 = (Object)adaptor.nil();
 1779  
                     // 109:48: -> ^( AS expression var )
 1780  
                     {
 1781  
                         // com\\googlecode\\sparkleg\\Sparql.g:109:51: ^( AS expression var )
 1782  
                         {
 1783  250
                         Object root_1 = (Object)adaptor.nil();
 1784  250
                         root_1 = (Object)adaptor.becomeRoot(
 1785  
                         stream_AS.nextNode()
 1786  
                         , root_1);
 1787  
 
 1788  250
                         adaptor.addChild(root_1, stream_expression.nextTree());
 1789  
 
 1790  250
                         adaptor.addChild(root_1, stream_var.nextTree());
 1791  
 
 1792  250
                         adaptor.addChild(root_0, root_1);
 1793  
                         }
 1794  
 
 1795  
                     }
 1796  
 
 1797  
 
 1798  250
                     retval.tree = root_0;
 1799  
 
 1800  
                     }
 1801  
                     break;
 1802  
 
 1803  
             }
 1804  1656
             retval.stop = input.LT(-1);
 1805  
 
 1806  
 
 1807  1656
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1808  1656
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1809  
 
 1810  
         }
 1811  0
         catch (RecognitionException re) {
 1812  0
             reportError(re);
 1813  0
             recover(input,re);
 1814  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1815  
 
 1816  
         }
 1817  
 
 1818  0
         finally {
 1819  
                 // do for sure before leaving
 1820  1656
         }
 1821  1656
         return retval;
 1822  
     }
 1823  
     // $ANTLR end "selectVariables"
 1824  
 
 1825  
 
 1826  72
     public static class constructQuery_return extends ParserRuleReturnScope {
 1827  
         Object tree;
 1828  72
         public Object getTree() { return tree; }
 1829  
     };
 1830  
 
 1831  
 
 1832  
     // $ANTLR start "constructQuery"
 1833  
     // com\\googlecode\\sparkleg\\Sparql.g:112:1: constructQuery : ( CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* ) | CONSTRUCT ( datasetClause )* WHERE groupGraphPattern solutionModifier -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* ) );
 1834  
     public final SparqlParser.constructQuery_return constructQuery() throws RecognitionException {
 1835  72
         SparqlParser.constructQuery_return retval = new SparqlParser.constructQuery_return();
 1836  72
         retval.start = input.LT(1);
 1837  
 
 1838  
 
 1839  72
         Object root_0 = null;
 1840  
 
 1841  72
         Token CONSTRUCT39=null;
 1842  72
         Token CONSTRUCT44=null;
 1843  72
         Token WHERE46=null;
 1844  72
         SparqlParser.constructTemplate_return constructTemplate40 =null;
 1845  
 
 1846  72
         SparqlParser.datasetClause_return datasetClause41 =null;
 1847  
 
 1848  72
         SparqlParser.whereClause_return whereClause42 =null;
 1849  
 
 1850  72
         SparqlParser.solutionModifier_return solutionModifier43 =null;
 1851  
 
 1852  72
         SparqlParser.datasetClause_return datasetClause45 =null;
 1853  
 
 1854  72
         SparqlParser.groupGraphPattern_return groupGraphPattern47 =null;
 1855  
 
 1856  72
         SparqlParser.solutionModifier_return solutionModifier48 =null;
 1857  
 
 1858  
 
 1859  72
         Object CONSTRUCT39_tree=null;
 1860  72
         Object CONSTRUCT44_tree=null;
 1861  72
         Object WHERE46_tree=null;
 1862  72
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 1863  72
         RewriteRuleTokenStream stream_CONSTRUCT=new RewriteRuleTokenStream(adaptor,"token CONSTRUCT");
 1864  72
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1865  72
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 1866  72
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 1867  72
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1868  72
         RewriteRuleSubtreeStream stream_constructTemplate=new RewriteRuleSubtreeStream(adaptor,"rule constructTemplate");
 1869  
         try {
 1870  
             // com\\googlecode\\sparkleg\\Sparql.g:113:5: ( CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* ) | CONSTRUCT ( datasetClause )* WHERE groupGraphPattern solutionModifier -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* ) )
 1871  72
             int alt14=2;
 1872  72
             switch ( input.LA(1) ) {
 1873  
             case CONSTRUCT:
 1874  
                 {
 1875  72
                 switch ( input.LA(2) ) {
 1876  
                 case OPEN_CURLY_BRACE:
 1877  
                     {
 1878  54
                     alt14=1;
 1879  
                     }
 1880  54
                     break;
 1881  
                 case FROM:
 1882  
                 case WHERE:
 1883  
                     {
 1884  16
                     alt14=2;
 1885  
                     }
 1886  16
                     break;
 1887  
                 default:
 1888  2
                     NoViableAltException nvae =
 1889  
                         new NoViableAltException("", 14, 1, input);
 1890  
 
 1891  2
                     throw nvae;
 1892  
 
 1893  
                 }
 1894  
 
 1895  
                 }
 1896  70
                 break;
 1897  
             default:
 1898  0
                 NoViableAltException nvae =
 1899  
                     new NoViableAltException("", 14, 0, input);
 1900  
 
 1901  0
                 throw nvae;
 1902  
 
 1903  
             }
 1904  
 
 1905  70
             switch (alt14) {
 1906  
                 case 1 :
 1907  
                     // com\\googlecode\\sparkleg\\Sparql.g:113:7: CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier
 1908  
                     {
 1909  54
                     CONSTRUCT39=(Token)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery558);  
 1910  54
                     stream_CONSTRUCT.add(CONSTRUCT39);
 1911  
 
 1912  
 
 1913  54
                     pushFollow(FOLLOW_constructTemplate_in_constructQuery560);
 1914  54
                     constructTemplate40=constructTemplate();
 1915  
 
 1916  54
                     state._fsp--;
 1917  
 
 1918  54
                     stream_constructTemplate.add(constructTemplate40.getTree());
 1919  
 
 1920  
                     // com\\googlecode\\sparkleg\\Sparql.g:113:35: ( datasetClause )*
 1921  
                     loop12:
 1922  
                     do {
 1923  54
                         int alt12=2;
 1924  54
                         switch ( input.LA(1) ) {
 1925  
                         case FROM:
 1926  
                             {
 1927  0
                             alt12=1;
 1928  
                             }
 1929  
                             break;
 1930  
 
 1931  
                         }
 1932  
 
 1933  54
                         switch (alt12) {
 1934  
                             case 1 :
 1935  
                                 // com\\googlecode\\sparkleg\\Sparql.g:113:35: datasetClause
 1936  
                                 {
 1937  0
                                 pushFollow(FOLLOW_datasetClause_in_constructQuery562);
 1938  0
                                 datasetClause41=datasetClause();
 1939  
 
 1940  0
                                 state._fsp--;
 1941  
 
 1942  0
                                 stream_datasetClause.add(datasetClause41.getTree());
 1943  
 
 1944  
                                 }
 1945  0
                                 break;
 1946  
 
 1947  
                             default :
 1948  54
                                 break loop12;
 1949  
                         }
 1950  0
                     } while (true);
 1951  
 
 1952  
 
 1953  54
                     pushFollow(FOLLOW_whereClause_in_constructQuery565);
 1954  54
                     whereClause42=whereClause();
 1955  
 
 1956  54
                     state._fsp--;
 1957  
 
 1958  54
                     stream_whereClause.add(whereClause42.getTree());
 1959  
 
 1960  54
                     pushFollow(FOLLOW_solutionModifier_in_constructQuery567);
 1961  54
                     solutionModifier43=solutionModifier();
 1962  
 
 1963  54
                     state._fsp--;
 1964  
 
 1965  54
                     stream_solutionModifier.add(solutionModifier43.getTree());
 1966  
 
 1967  
                     // AST REWRITE
 1968  
                     // elements: datasetClause, CONSTRUCT, solutionModifier, constructTemplate, whereClause
 1969  
                     // token labels: 
 1970  
                     // rule labels: retval
 1971  
                     // token list labels: 
 1972  
                     // rule list labels: 
 1973  
                     // wildcard labels: 
 1974  54
                     retval.tree = root_0;
 1975  54
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1976  
 
 1977  54
                     root_0 = (Object)adaptor.nil();
 1978  
                     // 113:79: -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1979  
                     {
 1980  
                         // com\\googlecode\\sparkleg\\Sparql.g:113:82: ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1981  
                         {
 1982  54
                         Object root_1 = (Object)adaptor.nil();
 1983  54
                         root_1 = (Object)adaptor.becomeRoot(
 1984  
                         stream_CONSTRUCT.nextNode()
 1985  
                         , root_1);
 1986  
 
 1987  54
                         adaptor.addChild(root_1, stream_constructTemplate.nextTree());
 1988  
 
 1989  
                         // com\\googlecode\\sparkleg\\Sparql.g:113:112: ( datasetClause )*
 1990  54
                         while ( stream_datasetClause.hasNext() ) {
 1991  0
                             adaptor.addChild(root_1, stream_datasetClause.nextTree());
 1992  
 
 1993  
                         }
 1994  54
                         stream_datasetClause.reset();
 1995  
 
 1996  
                         // com\\googlecode\\sparkleg\\Sparql.g:113:127: ( whereClause )*
 1997  108
                         while ( stream_whereClause.hasNext() ) {
 1998  54
                             adaptor.addChild(root_1, stream_whereClause.nextTree());
 1999  
 
 2000  
                         }
 2001  54
                         stream_whereClause.reset();
 2002  
 
 2003  
                         // com\\googlecode\\sparkleg\\Sparql.g:113:140: ( solutionModifier )*
 2004  60
                         while ( stream_solutionModifier.hasNext() ) {
 2005  6
                             adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2006  
 
 2007  
                         }
 2008  54
                         stream_solutionModifier.reset();
 2009  
 
 2010  54
                         adaptor.addChild(root_0, root_1);
 2011  
                         }
 2012  
 
 2013  
                     }
 2014  
 
 2015  
 
 2016  54
                     retval.tree = root_0;
 2017  
 
 2018  
                     }
 2019  54
                     break;
 2020  
                 case 2 :
 2021  
                     // com\\googlecode\\sparkleg\\Sparql.g:114:7: CONSTRUCT ( datasetClause )* WHERE groupGraphPattern solutionModifier
 2022  
                     {
 2023  16
                     CONSTRUCT44=(Token)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery592);  
 2024  16
                     stream_CONSTRUCT.add(CONSTRUCT44);
 2025  
 
 2026  
 
 2027  
                     // com\\googlecode\\sparkleg\\Sparql.g:114:17: ( datasetClause )*
 2028  
                     loop13:
 2029  
                     do {
 2030  18
                         int alt13=2;
 2031  18
                         switch ( input.LA(1) ) {
 2032  
                         case FROM:
 2033  
                             {
 2034  2
                             alt13=1;
 2035  
                             }
 2036  
                             break;
 2037  
 
 2038  
                         }
 2039  
 
 2040  18
                         switch (alt13) {
 2041  
                             case 1 :
 2042  
                                 // com\\googlecode\\sparkleg\\Sparql.g:114:17: datasetClause
 2043  
                                 {
 2044  2
                                 pushFollow(FOLLOW_datasetClause_in_constructQuery594);
 2045  2
                                 datasetClause45=datasetClause();
 2046  
 
 2047  2
                                 state._fsp--;
 2048  
 
 2049  2
                                 stream_datasetClause.add(datasetClause45.getTree());
 2050  
 
 2051  
                                 }
 2052  2
                                 break;
 2053  
 
 2054  
                             default :
 2055  16
                                 break loop13;
 2056  
                         }
 2057  2
                     } while (true);
 2058  
 
 2059  
 
 2060  16
                     WHERE46=(Token)match(input,WHERE,FOLLOW_WHERE_in_constructQuery597);  
 2061  16
                     stream_WHERE.add(WHERE46);
 2062  
 
 2063  
 
 2064  16
                     pushFollow(FOLLOW_groupGraphPattern_in_constructQuery599);
 2065  16
                     groupGraphPattern47=groupGraphPattern();
 2066  
 
 2067  16
                     state._fsp--;
 2068  
 
 2069  16
                     stream_groupGraphPattern.add(groupGraphPattern47.getTree());
 2070  
 
 2071  16
                     pushFollow(FOLLOW_solutionModifier_in_constructQuery601);
 2072  16
                     solutionModifier48=solutionModifier();
 2073  
 
 2074  16
                     state._fsp--;
 2075  
 
 2076  16
                     stream_solutionModifier.add(solutionModifier48.getTree());
 2077  
 
 2078  
                     // AST REWRITE
 2079  
                     // elements: CONSTRUCT, solutionModifier, datasetClause, groupGraphPattern
 2080  
                     // token labels: 
 2081  
                     // rule labels: retval
 2082  
                     // token list labels: 
 2083  
                     // rule list labels: 
 2084  
                     // wildcard labels: 
 2085  16
                     retval.tree = root_0;
 2086  16
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2087  
 
 2088  16
                     root_0 = (Object)adaptor.nil();
 2089  
                     // 114:73: -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* )
 2090  
                     {
 2091  
                         // com\\googlecode\\sparkleg\\Sparql.g:114:76: ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* )
 2092  
                         {
 2093  16
                         Object root_1 = (Object)adaptor.nil();
 2094  16
                         root_1 = (Object)adaptor.becomeRoot(
 2095  
                         stream_CONSTRUCT.nextNode()
 2096  
                         , root_1);
 2097  
 
 2098  
                         // com\\googlecode\\sparkleg\\Sparql.g:114:88: ( datasetClause )*
 2099  18
                         while ( stream_datasetClause.hasNext() ) {
 2100  2
                             adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2101  
 
 2102  
                         }
 2103  16
                         stream_datasetClause.reset();
 2104  
 
 2105  
                         // com\\googlecode\\sparkleg\\Sparql.g:114:103: ^( WHERE_CLAUSE ( groupGraphPattern )* )
 2106  
                         {
 2107  16
                         Object root_2 = (Object)adaptor.nil();
 2108  16
                         root_2 = (Object)adaptor.becomeRoot(
 2109  
                         (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 2110  
                         , root_2);
 2111  
 
 2112  
                         // com\\googlecode\\sparkleg\\Sparql.g:114:118: ( groupGraphPattern )*
 2113  32
                         while ( stream_groupGraphPattern.hasNext() ) {
 2114  16
                             adaptor.addChild(root_2, stream_groupGraphPattern.nextTree());
 2115  
 
 2116  
                         }
 2117  16
                         stream_groupGraphPattern.reset();
 2118  
 
 2119  16
                         adaptor.addChild(root_1, root_2);
 2120  
                         }
 2121  
 
 2122  
                         // com\\googlecode\\sparkleg\\Sparql.g:114:138: ( solutionModifier )*
 2123  16
                         while ( stream_solutionModifier.hasNext() ) {
 2124  0
                             adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2125  
 
 2126  
                         }
 2127  16
                         stream_solutionModifier.reset();
 2128  
 
 2129  16
                         adaptor.addChild(root_0, root_1);
 2130  
                         }
 2131  
 
 2132  
                     }
 2133  
 
 2134  
 
 2135  16
                     retval.tree = root_0;
 2136  
 
 2137  
                     }
 2138  
                     break;
 2139  
 
 2140  
             }
 2141  70
             retval.stop = input.LT(-1);
 2142  
 
 2143  
 
 2144  70
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2145  70
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2146  
 
 2147  
         }
 2148  2
         catch (RecognitionException re) {
 2149  2
             reportError(re);
 2150  2
             recover(input,re);
 2151  2
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2152  
 
 2153  
         }
 2154  
 
 2155  0
         finally {
 2156  
                 // do for sure before leaving
 2157  72
         }
 2158  72
         return retval;
 2159  
     }
 2160  
     // $ANTLR end "constructQuery"
 2161  
 
 2162  
 
 2163  28
     public static class describeQuery_return extends ParserRuleReturnScope {
 2164  
         Object tree;
 2165  28
         public Object getTree() { return tree; }
 2166  
     };
 2167  
 
 2168  
 
 2169  
     // $ANTLR start "describeQuery"
 2170  
     // com\\googlecode\\sparkleg\\Sparql.g:117:1: describeQuery : DESCRIBE ( (v+= varOrIRIref )+ | ASTERISK ) ( datasetClause )* ( whereClause )? solutionModifier -> ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* ) ;
 2171  
     public final SparqlParser.describeQuery_return describeQuery() throws RecognitionException {
 2172  28
         SparqlParser.describeQuery_return retval = new SparqlParser.describeQuery_return();
 2173  28
         retval.start = input.LT(1);
 2174  
 
 2175  
 
 2176  28
         Object root_0 = null;
 2177  
 
 2178  28
         Token DESCRIBE49=null;
 2179  28
         Token ASTERISK50=null;
 2180  28
         List list_v=null;
 2181  28
         SparqlParser.datasetClause_return datasetClause51 =null;
 2182  
 
 2183  28
         SparqlParser.whereClause_return whereClause52 =null;
 2184  
 
 2185  28
         SparqlParser.solutionModifier_return solutionModifier53 =null;
 2186  
 
 2187  28
         RuleReturnScope v = null;
 2188  28
         Object DESCRIBE49_tree=null;
 2189  28
         Object ASTERISK50_tree=null;
 2190  28
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 2191  28
         RewriteRuleTokenStream stream_DESCRIBE=new RewriteRuleTokenStream(adaptor,"token DESCRIBE");
 2192  28
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 2193  28
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 2194  28
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 2195  28
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 2196  
         try {
 2197  
             // com\\googlecode\\sparkleg\\Sparql.g:118:5: ( DESCRIBE ( (v+= varOrIRIref )+ | ASTERISK ) ( datasetClause )* ( whereClause )? solutionModifier -> ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* ) )
 2198  
             // com\\googlecode\\sparkleg\\Sparql.g:118:7: DESCRIBE ( (v+= varOrIRIref )+ | ASTERISK ) ( datasetClause )* ( whereClause )? solutionModifier
 2199  
             {
 2200  28
             DESCRIBE49=(Token)match(input,DESCRIBE,FOLLOW_DESCRIBE_in_describeQuery637);  
 2201  28
             stream_DESCRIBE.add(DESCRIBE49);
 2202  
 
 2203  
 
 2204  
             // com\\googlecode\\sparkleg\\Sparql.g:118:16: ( (v+= varOrIRIref )+ | ASTERISK )
 2205  28
             int alt16=2;
 2206  28
             switch ( input.LA(1) ) {
 2207  
             case IRI_REF:
 2208  
             case PNAME_LN:
 2209  
             case PNAME_NS:
 2210  
             case VAR1:
 2211  
             case VAR2:
 2212  
                 {
 2213  28
                 alt16=1;
 2214  
                 }
 2215  28
                 break;
 2216  
             case ASTERISK:
 2217  
                 {
 2218  0
                 alt16=2;
 2219  
                 }
 2220  0
                 break;
 2221  
             default:
 2222  0
                 NoViableAltException nvae =
 2223  
                     new NoViableAltException("", 16, 0, input);
 2224  
 
 2225  0
                 throw nvae;
 2226  
 
 2227  
             }
 2228  
 
 2229  28
             switch (alt16) {
 2230  
                 case 1 :
 2231  
                     // com\\googlecode\\sparkleg\\Sparql.g:118:17: (v+= varOrIRIref )+
 2232  
                     {
 2233  
                     // com\\googlecode\\sparkleg\\Sparql.g:118:17: (v+= varOrIRIref )+
 2234  28
                     int cnt15=0;
 2235  
                     loop15:
 2236  
                     do {
 2237  70
                         int alt15=2;
 2238  70
                         switch ( input.LA(1) ) {
 2239  
                         case IRI_REF:
 2240  
                         case PNAME_LN:
 2241  
                         case PNAME_NS:
 2242  
                         case VAR1:
 2243  
                         case VAR2:
 2244  
                             {
 2245  42
                             alt15=1;
 2246  
                             }
 2247  
                             break;
 2248  
 
 2249  
                         }
 2250  
 
 2251  70
                         switch (alt15) {
 2252  
                             case 1 :
 2253  
                                 // com\\googlecode\\sparkleg\\Sparql.g:118:18: v+= varOrIRIref
 2254  
                                 {
 2255  42
                                 pushFollow(FOLLOW_varOrIRIref_in_describeQuery643);
 2256  42
                                 v=varOrIRIref();
 2257  
 
 2258  42
                                 state._fsp--;
 2259  
 
 2260  42
                                 stream_varOrIRIref.add(v.getTree());
 2261  42
                                 if (list_v==null) list_v=new ArrayList();
 2262  42
                                 list_v.add(v.getTree());
 2263  
 
 2264  
 
 2265  
                                 }
 2266  42
                                 break;
 2267  
 
 2268  
                             default :
 2269  28
                                 if ( cnt15 >= 1 ) break loop15;
 2270  0
                                 EarlyExitException eee =
 2271  
                                     new EarlyExitException(15, input);
 2272  0
                                 throw eee;
 2273  
                         }
 2274  42
                         cnt15++;
 2275  42
                     } while (true);
 2276  
 
 2277  
 
 2278  
                     }
 2279  28
                     break;
 2280  
                 case 2 :
 2281  
                     // com\\googlecode\\sparkleg\\Sparql.g:118:37: ASTERISK
 2282  
                     {
 2283  0
                     ASTERISK50=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_describeQuery649);  
 2284  0
                     stream_ASTERISK.add(ASTERISK50);
 2285  
 
 2286  
 
 2287  
                     }
 2288  
                     break;
 2289  
 
 2290  
             }
 2291  
 
 2292  
 
 2293  
             // com\\googlecode\\sparkleg\\Sparql.g:118:47: ( datasetClause )*
 2294  
             loop17:
 2295  
             do {
 2296  28
                 int alt17=2;
 2297  28
                 switch ( input.LA(1) ) {
 2298  
                 case FROM:
 2299  
                     {
 2300  0
                     alt17=1;
 2301  
                     }
 2302  
                     break;
 2303  
 
 2304  
                 }
 2305  
 
 2306  28
                 switch (alt17) {
 2307  
                     case 1 :
 2308  
                         // com\\googlecode\\sparkleg\\Sparql.g:118:47: datasetClause
 2309  
                         {
 2310  0
                         pushFollow(FOLLOW_datasetClause_in_describeQuery652);
 2311  0
                         datasetClause51=datasetClause();
 2312  
 
 2313  0
                         state._fsp--;
 2314  
 
 2315  0
                         stream_datasetClause.add(datasetClause51.getTree());
 2316  
 
 2317  
                         }
 2318  0
                         break;
 2319  
 
 2320  
                     default :
 2321  28
                         break loop17;
 2322  
                 }
 2323  0
             } while (true);
 2324  
 
 2325  
 
 2326  
             // com\\googlecode\\sparkleg\\Sparql.g:118:62: ( whereClause )?
 2327  28
             int alt18=2;
 2328  28
             switch ( input.LA(1) ) {
 2329  
                 case OPEN_CURLY_BRACE:
 2330  
                 case WHERE:
 2331  
                     {
 2332  22
                     alt18=1;
 2333  
                     }
 2334  
                     break;
 2335  
             }
 2336  
 
 2337  28
             switch (alt18) {
 2338  
                 case 1 :
 2339  
                     // com\\googlecode\\sparkleg\\Sparql.g:118:62: whereClause
 2340  
                     {
 2341  22
                     pushFollow(FOLLOW_whereClause_in_describeQuery655);
 2342  22
                     whereClause52=whereClause();
 2343  
 
 2344  22
                     state._fsp--;
 2345  
 
 2346  22
                     stream_whereClause.add(whereClause52.getTree());
 2347  
 
 2348  
                     }
 2349  
                     break;
 2350  
 
 2351  
             }
 2352  
 
 2353  
 
 2354  28
             pushFollow(FOLLOW_solutionModifier_in_describeQuery658);
 2355  28
             solutionModifier53=solutionModifier();
 2356  
 
 2357  28
             state._fsp--;
 2358  
 
 2359  28
             stream_solutionModifier.add(solutionModifier53.getTree());
 2360  
 
 2361  
             // AST REWRITE
 2362  
             // elements: DESCRIBE, solutionModifier, v, ASTERISK, whereClause, datasetClause
 2363  
             // token labels: 
 2364  
             // rule labels: retval
 2365  
             // token list labels: 
 2366  
             // rule list labels: v
 2367  
             // wildcard labels: 
 2368  28
             retval.tree = root_0;
 2369  28
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2370  28
             RewriteRuleSubtreeStream stream_v=new RewriteRuleSubtreeStream(adaptor,"token v",list_v);
 2371  28
             root_0 = (Object)adaptor.nil();
 2372  
             // 118:92: -> ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* )
 2373  
             {
 2374  
                 // com\\googlecode\\sparkleg\\Sparql.g:118:95: ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* )
 2375  
                 {
 2376  28
                 Object root_1 = (Object)adaptor.nil();
 2377  28
                 root_1 = (Object)adaptor.becomeRoot(
 2378  
                 stream_DESCRIBE.nextNode()
 2379  
                 , root_1);
 2380  
 
 2381  
                 // com\\googlecode\\sparkleg\\Sparql.g:118:107: ( $v)*
 2382  70
                 while ( stream_v.hasNext() ) {
 2383  42
                     adaptor.addChild(root_1, stream_v.nextTree());
 2384  
 
 2385  
                 }
 2386  28
                 stream_v.reset();
 2387  
 
 2388  
                 // com\\googlecode\\sparkleg\\Sparql.g:118:110: ( ASTERISK )*
 2389  28
                 while ( stream_ASTERISK.hasNext() ) {
 2390  0
                     adaptor.addChild(root_1, 
 2391  
                     stream_ASTERISK.nextNode()
 2392  
                     );
 2393  
 
 2394  
                 }
 2395  28
                 stream_ASTERISK.reset();
 2396  
 
 2397  
                 // com\\googlecode\\sparkleg\\Sparql.g:118:120: ( datasetClause )*
 2398  28
                 while ( stream_datasetClause.hasNext() ) {
 2399  0
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2400  
 
 2401  
                 }
 2402  28
                 stream_datasetClause.reset();
 2403  
 
 2404  
                 // com\\googlecode\\sparkleg\\Sparql.g:118:135: ( whereClause )?
 2405  28
                 if ( stream_whereClause.hasNext() ) {
 2406  22
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 2407  
 
 2408  
                 }
 2409  28
                 stream_whereClause.reset();
 2410  
 
 2411  
                 // com\\googlecode\\sparkleg\\Sparql.g:118:148: ( solutionModifier )*
 2412  28
                 while ( stream_solutionModifier.hasNext() ) {
 2413  0
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2414  
 
 2415  
                 }
 2416  28
                 stream_solutionModifier.reset();
 2417  
 
 2418  28
                 adaptor.addChild(root_0, root_1);
 2419  
                 }
 2420  
 
 2421  
             }
 2422  
 
 2423  
 
 2424  28
             retval.tree = root_0;
 2425  
 
 2426  
             }
 2427  
 
 2428  28
             retval.stop = input.LT(-1);
 2429  
 
 2430  
 
 2431  28
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2432  28
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2433  
 
 2434  
         }
 2435  0
         catch (RecognitionException re) {
 2436  0
             reportError(re);
 2437  0
             recover(input,re);
 2438  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2439  
 
 2440  
         }
 2441  
 
 2442  0
         finally {
 2443  
                 // do for sure before leaving
 2444  28
         }
 2445  28
         return retval;
 2446  
     }
 2447  
     // $ANTLR end "describeQuery"
 2448  
 
 2449  
 
 2450  120
     public static class askQuery_return extends ParserRuleReturnScope {
 2451  
         Object tree;
 2452  120
         public Object getTree() { return tree; }
 2453  
     };
 2454  
 
 2455  
 
 2456  
     // $ANTLR start "askQuery"
 2457  
     // com\\googlecode\\sparkleg\\Sparql.g:121:1: askQuery : ASK ( datasetClause )* whereClause -> ^( ASK ( datasetClause )* whereClause ) ;
 2458  
     public final SparqlParser.askQuery_return askQuery() throws RecognitionException {
 2459  120
         SparqlParser.askQuery_return retval = new SparqlParser.askQuery_return();
 2460  120
         retval.start = input.LT(1);
 2461  
 
 2462  
 
 2463  120
         Object root_0 = null;
 2464  
 
 2465  120
         Token ASK54=null;
 2466  120
         SparqlParser.datasetClause_return datasetClause55 =null;
 2467  
 
 2468  120
         SparqlParser.whereClause_return whereClause56 =null;
 2469  
 
 2470  
 
 2471  120
         Object ASK54_tree=null;
 2472  120
         RewriteRuleTokenStream stream_ASK=new RewriteRuleTokenStream(adaptor,"token ASK");
 2473  120
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 2474  120
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 2475  
         try {
 2476  
             // com\\googlecode\\sparkleg\\Sparql.g:122:5: ( ASK ( datasetClause )* whereClause -> ^( ASK ( datasetClause )* whereClause ) )
 2477  
             // com\\googlecode\\sparkleg\\Sparql.g:122:7: ASK ( datasetClause )* whereClause
 2478  
             {
 2479  120
             ASK54=(Token)match(input,ASK,FOLLOW_ASK_in_askQuery697);  
 2480  120
             stream_ASK.add(ASK54);
 2481  
 
 2482  
 
 2483  
             // com\\googlecode\\sparkleg\\Sparql.g:122:11: ( datasetClause )*
 2484  
             loop19:
 2485  
             do {
 2486  120
                 int alt19=2;
 2487  120
                 switch ( input.LA(1) ) {
 2488  
                 case FROM:
 2489  
                     {
 2490  0
                     alt19=1;
 2491  
                     }
 2492  
                     break;
 2493  
 
 2494  
                 }
 2495  
 
 2496  120
                 switch (alt19) {
 2497  
                     case 1 :
 2498  
                         // com\\googlecode\\sparkleg\\Sparql.g:122:11: datasetClause
 2499  
                         {
 2500  0
                         pushFollow(FOLLOW_datasetClause_in_askQuery699);
 2501  0
                         datasetClause55=datasetClause();
 2502  
 
 2503  0
                         state._fsp--;
 2504  
 
 2505  0
                         stream_datasetClause.add(datasetClause55.getTree());
 2506  
 
 2507  
                         }
 2508  0
                         break;
 2509  
 
 2510  
                     default :
 2511  120
                         break loop19;
 2512  
                 }
 2513  0
             } while (true);
 2514  
 
 2515  
 
 2516  120
             pushFollow(FOLLOW_whereClause_in_askQuery702);
 2517  120
             whereClause56=whereClause();
 2518  
 
 2519  120
             state._fsp--;
 2520  
 
 2521  120
             stream_whereClause.add(whereClause56.getTree());
 2522  
 
 2523  
             // AST REWRITE
 2524  
             // elements: datasetClause, ASK, whereClause
 2525  
             // token labels: 
 2526  
             // rule labels: retval
 2527  
             // token list labels: 
 2528  
             // rule list labels: 
 2529  
             // wildcard labels: 
 2530  120
             retval.tree = root_0;
 2531  120
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2532  
 
 2533  120
             root_0 = (Object)adaptor.nil();
 2534  
             // 122:38: -> ^( ASK ( datasetClause )* whereClause )
 2535  
             {
 2536  
                 // com\\googlecode\\sparkleg\\Sparql.g:122:41: ^( ASK ( datasetClause )* whereClause )
 2537  
                 {
 2538  120
                 Object root_1 = (Object)adaptor.nil();
 2539  120
                 root_1 = (Object)adaptor.becomeRoot(
 2540  
                 stream_ASK.nextNode()
 2541  
                 , root_1);
 2542  
 
 2543  
                 // com\\googlecode\\sparkleg\\Sparql.g:122:47: ( datasetClause )*
 2544  120
                 while ( stream_datasetClause.hasNext() ) {
 2545  0
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2546  
 
 2547  
                 }
 2548  120
                 stream_datasetClause.reset();
 2549  
 
 2550  120
                 adaptor.addChild(root_1, stream_whereClause.nextTree());
 2551  
 
 2552  120
                 adaptor.addChild(root_0, root_1);
 2553  
                 }
 2554  
 
 2555  
             }
 2556  
 
 2557  
 
 2558  120
             retval.tree = root_0;
 2559  
 
 2560  
             }
 2561  
 
 2562  120
             retval.stop = input.LT(-1);
 2563  
 
 2564  
 
 2565  120
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2566  120
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2567  
 
 2568  
         }
 2569  0
         catch (RecognitionException re) {
 2570  0
             reportError(re);
 2571  0
             recover(input,re);
 2572  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2573  
 
 2574  
         }
 2575  
 
 2576  0
         finally {
 2577  
                 // do for sure before leaving
 2578  120
         }
 2579  120
         return retval;
 2580  
     }
 2581  
     // $ANTLR end "askQuery"
 2582  
 
 2583  
 
 2584  160
     public static class datasetClause_return extends ParserRuleReturnScope {
 2585  
         Object tree;
 2586  160
         public Object getTree() { return tree; }
 2587  
     };
 2588  
 
 2589  
 
 2590  
     // $ANTLR start "datasetClause"
 2591  
     // com\\googlecode\\sparkleg\\Sparql.g:125:1: datasetClause : FROM ( NAMED )? iriRef -> ^( FROM ( NAMED )? iriRef ) ;
 2592  
     public final SparqlParser.datasetClause_return datasetClause() throws RecognitionException {
 2593  160
         SparqlParser.datasetClause_return retval = new SparqlParser.datasetClause_return();
 2594  160
         retval.start = input.LT(1);
 2595  
 
 2596  
 
 2597  160
         Object root_0 = null;
 2598  
 
 2599  160
         Token FROM57=null;
 2600  160
         Token NAMED58=null;
 2601  160
         SparqlParser.iriRef_return iriRef59 =null;
 2602  
 
 2603  
 
 2604  160
         Object FROM57_tree=null;
 2605  160
         Object NAMED58_tree=null;
 2606  160
         RewriteRuleTokenStream stream_FROM=new RewriteRuleTokenStream(adaptor,"token FROM");
 2607  160
         RewriteRuleTokenStream stream_NAMED=new RewriteRuleTokenStream(adaptor,"token NAMED");
 2608  160
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 2609  
         try {
 2610  
             // com\\googlecode\\sparkleg\\Sparql.g:126:5: ( FROM ( NAMED )? iriRef -> ^( FROM ( NAMED )? iriRef ) )
 2611  
             // com\\googlecode\\sparkleg\\Sparql.g:126:7: FROM ( NAMED )? iriRef
 2612  
             {
 2613  160
             FROM57=(Token)match(input,FROM,FOLLOW_FROM_in_datasetClause730);  
 2614  160
             stream_FROM.add(FROM57);
 2615  
 
 2616  
 
 2617  
             // com\\googlecode\\sparkleg\\Sparql.g:126:12: ( NAMED )?
 2618  160
             int alt20=2;
 2619  160
             switch ( input.LA(1) ) {
 2620  
                 case NAMED:
 2621  
                     {
 2622  102
                     alt20=1;
 2623  
                     }
 2624  
                     break;
 2625  
             }
 2626  
 
 2627  160
             switch (alt20) {
 2628  
                 case 1 :
 2629  
                     // com\\googlecode\\sparkleg\\Sparql.g:126:12: NAMED
 2630  
                     {
 2631  102
                     NAMED58=(Token)match(input,NAMED,FOLLOW_NAMED_in_datasetClause732);  
 2632  102
                     stream_NAMED.add(NAMED58);
 2633  
 
 2634  
 
 2635  
                     }
 2636  
                     break;
 2637  
 
 2638  
             }
 2639  
 
 2640  
 
 2641  160
             pushFollow(FOLLOW_iriRef_in_datasetClause735);
 2642  160
             iriRef59=iriRef();
 2643  
 
 2644  160
             state._fsp--;
 2645  
 
 2646  160
             stream_iriRef.add(iriRef59.getTree());
 2647  
 
 2648  
             // AST REWRITE
 2649  
             // elements: NAMED, iriRef, FROM
 2650  
             // token labels: 
 2651  
             // rule labels: retval
 2652  
             // token list labels: 
 2653  
             // rule list labels: 
 2654  
             // wildcard labels: 
 2655  160
             retval.tree = root_0;
 2656  160
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2657  
 
 2658  160
             root_0 = (Object)adaptor.nil();
 2659  
             // 126:26: -> ^( FROM ( NAMED )? iriRef )
 2660  
             {
 2661  
                 // com\\googlecode\\sparkleg\\Sparql.g:126:29: ^( FROM ( NAMED )? iriRef )
 2662  
                 {
 2663  160
                 Object root_1 = (Object)adaptor.nil();
 2664  160
                 root_1 = (Object)adaptor.becomeRoot(
 2665  
                 stream_FROM.nextNode()
 2666  
                 , root_1);
 2667  
 
 2668  
                 // com\\googlecode\\sparkleg\\Sparql.g:126:36: ( NAMED )?
 2669  160
                 if ( stream_NAMED.hasNext() ) {
 2670  102
                     adaptor.addChild(root_1, 
 2671  
                     stream_NAMED.nextNode()
 2672  
                     );
 2673  
 
 2674  
                 }
 2675  160
                 stream_NAMED.reset();
 2676  
 
 2677  160
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 2678  
 
 2679  160
                 adaptor.addChild(root_0, root_1);
 2680  
                 }
 2681  
 
 2682  
             }
 2683  
 
 2684  
 
 2685  160
             retval.tree = root_0;
 2686  
 
 2687  
             }
 2688  
 
 2689  160
             retval.stop = input.LT(-1);
 2690  
 
 2691  
 
 2692  160
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2693  160
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2694  
 
 2695  
         }
 2696  0
         catch (RecognitionException re) {
 2697  0
             reportError(re);
 2698  0
             recover(input,re);
 2699  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2700  
 
 2701  
         }
 2702  
 
 2703  0
         finally {
 2704  
                 // do for sure before leaving
 2705  160
         }
 2706  160
         return retval;
 2707  
     }
 2708  
     // $ANTLR end "datasetClause"
 2709  
 
 2710  
 
 2711  1856
     public static class whereClause_return extends ParserRuleReturnScope {
 2712  
         Object tree;
 2713  1856
         public Object getTree() { return tree; }
 2714  
     };
 2715  
 
 2716  
 
 2717  
     // $ANTLR start "whereClause"
 2718  
     // com\\googlecode\\sparkleg\\Sparql.g:129:1: whereClause : ( WHERE )? groupGraphPattern -> ^( WHERE_CLAUSE groupGraphPattern ) ;
 2719  
     public final SparqlParser.whereClause_return whereClause() throws RecognitionException {
 2720  1856
         SparqlParser.whereClause_return retval = new SparqlParser.whereClause_return();
 2721  1856
         retval.start = input.LT(1);
 2722  
 
 2723  
 
 2724  1856
         Object root_0 = null;
 2725  
 
 2726  1856
         Token WHERE60=null;
 2727  1856
         SparqlParser.groupGraphPattern_return groupGraphPattern61 =null;
 2728  
 
 2729  
 
 2730  1856
         Object WHERE60_tree=null;
 2731  1856
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 2732  1856
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 2733  
         try {
 2734  
             // com\\googlecode\\sparkleg\\Sparql.g:130:5: ( ( WHERE )? groupGraphPattern -> ^( WHERE_CLAUSE groupGraphPattern ) )
 2735  
             // com\\googlecode\\sparkleg\\Sparql.g:130:7: ( WHERE )? groupGraphPattern
 2736  
             {
 2737  
             // com\\googlecode\\sparkleg\\Sparql.g:130:7: ( WHERE )?
 2738  1856
             int alt21=2;
 2739  1856
             switch ( input.LA(1) ) {
 2740  
                 case WHERE:
 2741  
                     {
 2742  1356
                     alt21=1;
 2743  
                     }
 2744  
                     break;
 2745  
             }
 2746  
 
 2747  1856
             switch (alt21) {
 2748  
                 case 1 :
 2749  
                     // com\\googlecode\\sparkleg\\Sparql.g:130:7: WHERE
 2750  
                     {
 2751  1356
                     WHERE60=(Token)match(input,WHERE,FOLLOW_WHERE_in_whereClause763);  
 2752  1356
                     stream_WHERE.add(WHERE60);
 2753  
 
 2754  
 
 2755  
                     }
 2756  
                     break;
 2757  
 
 2758  
             }
 2759  
 
 2760  
 
 2761  1856
             pushFollow(FOLLOW_groupGraphPattern_in_whereClause766);
 2762  1856
             groupGraphPattern61=groupGraphPattern();
 2763  
 
 2764  1856
             state._fsp--;
 2765  
 
 2766  1856
             stream_groupGraphPattern.add(groupGraphPattern61.getTree());
 2767  
 
 2768  
             // AST REWRITE
 2769  
             // elements: groupGraphPattern
 2770  
             // token labels: 
 2771  
             // rule labels: retval
 2772  
             // token list labels: 
 2773  
             // rule list labels: 
 2774  
             // wildcard labels: 
 2775  1856
             retval.tree = root_0;
 2776  1856
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2777  
 
 2778  1856
             root_0 = (Object)adaptor.nil();
 2779  
             // 130:32: -> ^( WHERE_CLAUSE groupGraphPattern )
 2780  
             {
 2781  
                 // com\\googlecode\\sparkleg\\Sparql.g:130:35: ^( WHERE_CLAUSE groupGraphPattern )
 2782  
                 {
 2783  1856
                 Object root_1 = (Object)adaptor.nil();
 2784  1856
                 root_1 = (Object)adaptor.becomeRoot(
 2785  
                 (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 2786  
                 , root_1);
 2787  
 
 2788  1856
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 2789  
 
 2790  1856
                 adaptor.addChild(root_0, root_1);
 2791  
                 }
 2792  
 
 2793  
             }
 2794  
 
 2795  
 
 2796  1856
             retval.tree = root_0;
 2797  
 
 2798  
             }
 2799  
 
 2800  1856
             retval.stop = input.LT(-1);
 2801  
 
 2802  
 
 2803  1856
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2804  1856
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2805  
 
 2806  
         }
 2807  0
         catch (RecognitionException re) {
 2808  0
             reportError(re);
 2809  0
             recover(input,re);
 2810  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2811  
 
 2812  
         }
 2813  
 
 2814  0
         finally {
 2815  
                 // do for sure before leaving
 2816  1856
         }
 2817  1856
         return retval;
 2818  
     }
 2819  
     // $ANTLR end "whereClause"
 2820  
 
 2821  
 
 2822  1758
     public static class solutionModifier_return extends ParserRuleReturnScope {
 2823  
         Object tree;
 2824  1758
         public Object getTree() { return tree; }
 2825  
     };
 2826  
 
 2827  
 
 2828  
     // $ANTLR start "solutionModifier"
 2829  
     // com\\googlecode\\sparkleg\\Sparql.g:133:1: solutionModifier : ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )* ;
 2830  
     public final SparqlParser.solutionModifier_return solutionModifier() throws RecognitionException {
 2831  1758
         SparqlParser.solutionModifier_return retval = new SparqlParser.solutionModifier_return();
 2832  1758
         retval.start = input.LT(1);
 2833  
 
 2834  
 
 2835  1758
         Object root_0 = null;
 2836  
 
 2837  1758
         SparqlParser.groupClause_return groupClause62 =null;
 2838  
 
 2839  1758
         SparqlParser.havingClause_return havingClause63 =null;
 2840  
 
 2841  1758
         SparqlParser.orderClause_return orderClause64 =null;
 2842  
 
 2843  1758
         SparqlParser.limitOffsetClauses_return limitOffsetClauses65 =null;
 2844  
 
 2845  
 
 2846  1758
         RewriteRuleSubtreeStream stream_limitOffsetClauses=new RewriteRuleSubtreeStream(adaptor,"rule limitOffsetClauses");
 2847  1758
         RewriteRuleSubtreeStream stream_orderClause=new RewriteRuleSubtreeStream(adaptor,"rule orderClause");
 2848  1758
         RewriteRuleSubtreeStream stream_groupClause=new RewriteRuleSubtreeStream(adaptor,"rule groupClause");
 2849  1758
         RewriteRuleSubtreeStream stream_havingClause=new RewriteRuleSubtreeStream(adaptor,"rule havingClause");
 2850  
         try {
 2851  
             // com\\googlecode\\sparkleg\\Sparql.g:134:5: ( ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )* )
 2852  
             // com\\googlecode\\sparkleg\\Sparql.g:134:7: ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )?
 2853  
             {
 2854  
             // com\\googlecode\\sparkleg\\Sparql.g:134:7: ( groupClause )?
 2855  1758
             int alt22=2;
 2856  1758
             switch ( input.LA(1) ) {
 2857  
                 case GROUP:
 2858  
                     {
 2859  66
                     alt22=1;
 2860  
                     }
 2861  
                     break;
 2862  
             }
 2863  
 
 2864  1758
             switch (alt22) {
 2865  
                 case 1 :
 2866  
                     // com\\googlecode\\sparkleg\\Sparql.g:134:7: groupClause
 2867  
                     {
 2868  66
                     pushFollow(FOLLOW_groupClause_in_solutionModifier791);
 2869  66
                     groupClause62=groupClause();
 2870  
 
 2871  66
                     state._fsp--;
 2872  
 
 2873  66
                     stream_groupClause.add(groupClause62.getTree());
 2874  
 
 2875  
                     }
 2876  
                     break;
 2877  
 
 2878  
             }
 2879  
 
 2880  
 
 2881  
             // com\\googlecode\\sparkleg\\Sparql.g:134:20: ( havingClause )?
 2882  1758
             int alt23=2;
 2883  1758
             switch ( input.LA(1) ) {
 2884  
                 case HAVING:
 2885  
                     {
 2886  16
                     alt23=1;
 2887  
                     }
 2888  
                     break;
 2889  
             }
 2890  
 
 2891  1758
             switch (alt23) {
 2892  
                 case 1 :
 2893  
                     // com\\googlecode\\sparkleg\\Sparql.g:134:20: havingClause
 2894  
                     {
 2895  16
                     pushFollow(FOLLOW_havingClause_in_solutionModifier794);
 2896  16
                     havingClause63=havingClause();
 2897  
 
 2898  16
                     state._fsp--;
 2899  
 
 2900  16
                     stream_havingClause.add(havingClause63.getTree());
 2901  
 
 2902  
                     }
 2903  
                     break;
 2904  
 
 2905  
             }
 2906  
 
 2907  
 
 2908  
             // com\\googlecode\\sparkleg\\Sparql.g:134:34: ( orderClause )?
 2909  1758
             int alt24=2;
 2910  1758
             switch ( input.LA(1) ) {
 2911  
                 case ORDER:
 2912  
                     {
 2913  134
                     alt24=1;
 2914  
                     }
 2915  
                     break;
 2916  
             }
 2917  
 
 2918  1758
             switch (alt24) {
 2919  
                 case 1 :
 2920  
                     // com\\googlecode\\sparkleg\\Sparql.g:134:34: orderClause
 2921  
                     {
 2922  134
                     pushFollow(FOLLOW_orderClause_in_solutionModifier797);
 2923  134
                     orderClause64=orderClause();
 2924  
 
 2925  134
                     state._fsp--;
 2926  
 
 2927  134
                     stream_orderClause.add(orderClause64.getTree());
 2928  
 
 2929  
                     }
 2930  
                     break;
 2931  
 
 2932  
             }
 2933  
 
 2934  
 
 2935  
             // com\\googlecode\\sparkleg\\Sparql.g:134:47: ( limitOffsetClauses )?
 2936  1758
             int alt25=2;
 2937  1758
             switch ( input.LA(1) ) {
 2938  
                 case LIMIT:
 2939  
                 case OFFSET:
 2940  
                     {
 2941  58
                     alt25=1;
 2942  
                     }
 2943  
                     break;
 2944  
             }
 2945  
 
 2946  1758
             switch (alt25) {
 2947  
                 case 1 :
 2948  
                     // com\\googlecode\\sparkleg\\Sparql.g:134:47: limitOffsetClauses
 2949  
                     {
 2950  58
                     pushFollow(FOLLOW_limitOffsetClauses_in_solutionModifier800);
 2951  58
                     limitOffsetClauses65=limitOffsetClauses();
 2952  
 
 2953  58
                     state._fsp--;
 2954  
 
 2955  58
                     stream_limitOffsetClauses.add(limitOffsetClauses65.getTree());
 2956  
 
 2957  
                     }
 2958  
                     break;
 2959  
 
 2960  
             }
 2961  
 
 2962  
 
 2963  
             // AST REWRITE
 2964  
             // elements: havingClause, limitOffsetClauses, orderClause, groupClause
 2965  
             // token labels: 
 2966  
             // rule labels: retval
 2967  
             // token list labels: 
 2968  
             // rule list labels: 
 2969  
             // wildcard labels: 
 2970  1758
             retval.tree = root_0;
 2971  1758
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2972  
 
 2973  1758
             root_0 = (Object)adaptor.nil();
 2974  
             // 134:67: -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )*
 2975  
             {
 2976  
                 // com\\googlecode\\sparkleg\\Sparql.g:134:70: ( groupClause )*
 2977  1824
                 while ( stream_groupClause.hasNext() ) {
 2978  66
                     adaptor.addChild(root_0, stream_groupClause.nextTree());
 2979  
 
 2980  
                 }
 2981  1758
                 stream_groupClause.reset();
 2982  
 
 2983  
                 // com\\googlecode\\sparkleg\\Sparql.g:134:83: ( havingClause )*
 2984  1774
                 while ( stream_havingClause.hasNext() ) {
 2985  16
                     adaptor.addChild(root_0, stream_havingClause.nextTree());
 2986  
 
 2987  
                 }
 2988  1758
                 stream_havingClause.reset();
 2989  
 
 2990  
                 // com\\googlecode\\sparkleg\\Sparql.g:134:97: ( orderClause )*
 2991  1892
                 while ( stream_orderClause.hasNext() ) {
 2992  134
                     adaptor.addChild(root_0, stream_orderClause.nextTree());
 2993  
 
 2994  
                 }
 2995  1758
                 stream_orderClause.reset();
 2996  
 
 2997  
                 // com\\googlecode\\sparkleg\\Sparql.g:134:110: ( limitOffsetClauses )*
 2998  1816
                 while ( stream_limitOffsetClauses.hasNext() ) {
 2999  58
                     adaptor.addChild(root_0, stream_limitOffsetClauses.nextTree());
 3000  
 
 3001  
                 }
 3002  1758
                 stream_limitOffsetClauses.reset();
 3003  
 
 3004  
             }
 3005  
 
 3006  
 
 3007  1758
             retval.tree = root_0;
 3008  
 
 3009  
             }
 3010  
 
 3011  1758
             retval.stop = input.LT(-1);
 3012  
 
 3013  
 
 3014  1758
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3015  1758
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3016  
 
 3017  
         }
 3018  0
         catch (RecognitionException re) {
 3019  0
             reportError(re);
 3020  0
             recover(input,re);
 3021  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3022  
 
 3023  
         }
 3024  
 
 3025  0
         finally {
 3026  
                 // do for sure before leaving
 3027  1758
         }
 3028  1758
         return retval;
 3029  
     }
 3030  
     // $ANTLR end "solutionModifier"
 3031  
 
 3032  
 
 3033  66
     public static class groupClause_return extends ParserRuleReturnScope {
 3034  
         Object tree;
 3035  66
         public Object getTree() { return tree; }
 3036  
     };
 3037  
 
 3038  
 
 3039  
     // $ANTLR start "groupClause"
 3040  
     // com\\googlecode\\sparkleg\\Sparql.g:137:1: groupClause : GROUP BY ( groupCondition )+ -> ^( GROUP_BY ( groupCondition )+ ) ;
 3041  
     public final SparqlParser.groupClause_return groupClause() throws RecognitionException {
 3042  66
         SparqlParser.groupClause_return retval = new SparqlParser.groupClause_return();
 3043  66
         retval.start = input.LT(1);
 3044  
 
 3045  
 
 3046  66
         Object root_0 = null;
 3047  
 
 3048  66
         Token GROUP66=null;
 3049  66
         Token BY67=null;
 3050  66
         SparqlParser.groupCondition_return groupCondition68 =null;
 3051  
 
 3052  
 
 3053  66
         Object GROUP66_tree=null;
 3054  66
         Object BY67_tree=null;
 3055  66
         RewriteRuleTokenStream stream_GROUP=new RewriteRuleTokenStream(adaptor,"token GROUP");
 3056  66
         RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
 3057  66
         RewriteRuleSubtreeStream stream_groupCondition=new RewriteRuleSubtreeStream(adaptor,"rule groupCondition");
 3058  
         try {
 3059  
             // com\\googlecode\\sparkleg\\Sparql.g:138:5: ( GROUP BY ( groupCondition )+ -> ^( GROUP_BY ( groupCondition )+ ) )
 3060  
             // com\\googlecode\\sparkleg\\Sparql.g:138:7: GROUP BY ( groupCondition )+
 3061  
             {
 3062  66
             GROUP66=(Token)match(input,GROUP,FOLLOW_GROUP_in_groupClause832);  
 3063  66
             stream_GROUP.add(GROUP66);
 3064  
 
 3065  
 
 3066  66
             BY67=(Token)match(input,BY,FOLLOW_BY_in_groupClause834);  
 3067  66
             stream_BY.add(BY67);
 3068  
 
 3069  
 
 3070  
             // com\\googlecode\\sparkleg\\Sparql.g:138:16: ( groupCondition )+
 3071  66
             int cnt26=0;
 3072  
             loop26:
 3073  
             do {
 3074  136
                 int alt26=2;
 3075  136
                 switch ( input.LA(1) ) {
 3076  
                 case ABS:
 3077  
                 case BNODE:
 3078  
                 case BOUND:
 3079  
                 case CEIL:
 3080  
                 case COALESCE:
 3081  
                 case CONCAT:
 3082  
                 case CONTAINS:
 3083  
                 case DATATYPE:
 3084  
                 case DAY:
 3085  
                 case ENCODE_FOR_URI:
 3086  
                 case EXISTS:
 3087  
                 case FLOOR:
 3088  
                 case HOURS:
 3089  
                 case IF:
 3090  
                 case IRI:
 3091  
                 case IRI_REF:
 3092  
                 case ISBLANK:
 3093  
                 case ISIRI:
 3094  
                 case ISLITERAL:
 3095  
                 case ISNUMERIC:
 3096  
                 case ISURI:
 3097  
                 case LANG:
 3098  
                 case LANGMATCHES:
 3099  
                 case LCASE:
 3100  
                 case MD5:
 3101  
                 case MINUTES:
 3102  
                 case MONTH:
 3103  
                 case NOT:
 3104  
                 case NOW:
 3105  
                 case OPEN_BRACE:
 3106  
                 case PNAME_LN:
 3107  
                 case PNAME_NS:
 3108  
                 case RAND:
 3109  
                 case REGEX:
 3110  
                 case REPLACE:
 3111  
                 case ROUND:
 3112  
                 case SAMETERM:
 3113  
                 case SECONDS:
 3114  
                 case SHA1:
 3115  
                 case SHA224:
 3116  
                 case SHA256:
 3117  
                 case SHA384:
 3118  
                 case SHA512:
 3119  
                 case STR:
 3120  
                 case STRAFTER:
 3121  
                 case STRBEFORE:
 3122  
                 case STRDT:
 3123  
                 case STRENDS:
 3124  
                 case STRLANG:
 3125  
                 case STRLEN:
 3126  
                 case STRSTARTS:
 3127  
                 case SUBSTR:
 3128  
                 case TIMEZONE:
 3129  
                 case TZ:
 3130  
                 case UCASE:
 3131  
                 case URI:
 3132  
                 case VAR1:
 3133  
                 case VAR2:
 3134  
                 case YEAR:
 3135  
                     {
 3136  70
                     alt26=1;
 3137  
                     }
 3138  
                     break;
 3139  
 
 3140  
                 }
 3141  
 
 3142  136
                 switch (alt26) {
 3143  
                     case 1 :
 3144  
                         // com\\googlecode\\sparkleg\\Sparql.g:138:16: groupCondition
 3145  
                         {
 3146  70
                         pushFollow(FOLLOW_groupCondition_in_groupClause836);
 3147  70
                         groupCondition68=groupCondition();
 3148  
 
 3149  70
                         state._fsp--;
 3150  
 
 3151  70
                         stream_groupCondition.add(groupCondition68.getTree());
 3152  
 
 3153  
                         }
 3154  70
                         break;
 3155  
 
 3156  
                     default :
 3157  66
                         if ( cnt26 >= 1 ) break loop26;
 3158  0
                         EarlyExitException eee =
 3159  
                             new EarlyExitException(26, input);
 3160  0
                         throw eee;
 3161  
                 }
 3162  70
                 cnt26++;
 3163  70
             } while (true);
 3164  
 
 3165  
 
 3166  
             // AST REWRITE
 3167  
             // elements: groupCondition
 3168  
             // token labels: 
 3169  
             // rule labels: retval
 3170  
             // token list labels: 
 3171  
             // rule list labels: 
 3172  
             // wildcard labels: 
 3173  66
             retval.tree = root_0;
 3174  66
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3175  
 
 3176  66
             root_0 = (Object)adaptor.nil();
 3177  
             // 138:32: -> ^( GROUP_BY ( groupCondition )+ )
 3178  
             {
 3179  
                 // com\\googlecode\\sparkleg\\Sparql.g:138:35: ^( GROUP_BY ( groupCondition )+ )
 3180  
                 {
 3181  66
                 Object root_1 = (Object)adaptor.nil();
 3182  66
                 root_1 = (Object)adaptor.becomeRoot(
 3183  
                 (Object)adaptor.create(GROUP_BY, "GROUP_BY")
 3184  
                 , root_1);
 3185  
 
 3186  66
                 if ( !(stream_groupCondition.hasNext()) ) {
 3187  0
                     throw new RewriteEarlyExitException();
 3188  
                 }
 3189  136
                 while ( stream_groupCondition.hasNext() ) {
 3190  70
                     adaptor.addChild(root_1, stream_groupCondition.nextTree());
 3191  
 
 3192  
                 }
 3193  66
                 stream_groupCondition.reset();
 3194  
 
 3195  66
                 adaptor.addChild(root_0, root_1);
 3196  
                 }
 3197  
 
 3198  
             }
 3199  
 
 3200  
 
 3201  66
             retval.tree = root_0;
 3202  
 
 3203  
             }
 3204  
 
 3205  66
             retval.stop = input.LT(-1);
 3206  
 
 3207  
 
 3208  66
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3209  66
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3210  
 
 3211  
         }
 3212  0
         catch (RecognitionException re) {
 3213  0
             reportError(re);
 3214  0
             recover(input,re);
 3215  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3216  
 
 3217  
         }
 3218  
 
 3219  0
         finally {
 3220  
                 // do for sure before leaving
 3221  66
         }
 3222  66
         return retval;
 3223  
     }
 3224  
     // $ANTLR end "groupClause"
 3225  
 
 3226  
 
 3227  70
     public static class groupCondition_return extends ParserRuleReturnScope {
 3228  
         Object tree;
 3229  70
         public Object getTree() { return tree; }
 3230  
     };
 3231  
 
 3232  
 
 3233  
     // $ANTLR start "groupCondition"
 3234  
     // com\\googlecode\\sparkleg\\Sparql.g:141:1: groupCondition : ( builtInCall -> ^( GROUP_CONDITION builtInCall ) | functionCall -> ^( GROUP_CONDITION functionCall ) | OPEN_BRACE expression ( AS var )? CLOSE_BRACE -> ^( GROUP_CONDITION expression ( ^( AS var ) )? ) | var -> ^( GROUP_CONDITION var ) );
 3235  
     public final SparqlParser.groupCondition_return groupCondition() throws RecognitionException {
 3236  70
         SparqlParser.groupCondition_return retval = new SparqlParser.groupCondition_return();
 3237  70
         retval.start = input.LT(1);
 3238  
 
 3239  
 
 3240  70
         Object root_0 = null;
 3241  
 
 3242  70
         Token OPEN_BRACE71=null;
 3243  70
         Token AS73=null;
 3244  70
         Token CLOSE_BRACE75=null;
 3245  70
         SparqlParser.builtInCall_return builtInCall69 =null;
 3246  
 
 3247  70
         SparqlParser.functionCall_return functionCall70 =null;
 3248  
 
 3249  70
         SparqlParser.expression_return expression72 =null;
 3250  
 
 3251  70
         SparqlParser.var_return var74 =null;
 3252  
 
 3253  70
         SparqlParser.var_return var76 =null;
 3254  
 
 3255  
 
 3256  70
         Object OPEN_BRACE71_tree=null;
 3257  70
         Object AS73_tree=null;
 3258  70
         Object CLOSE_BRACE75_tree=null;
 3259  70
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 3260  70
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 3261  70
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 3262  70
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 3263  70
         RewriteRuleSubtreeStream stream_functionCall=new RewriteRuleSubtreeStream(adaptor,"rule functionCall");
 3264  70
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 3265  70
         RewriteRuleSubtreeStream stream_builtInCall=new RewriteRuleSubtreeStream(adaptor,"rule builtInCall");
 3266  
         try {
 3267  
             // com\\googlecode\\sparkleg\\Sparql.g:142:5: ( builtInCall -> ^( GROUP_CONDITION builtInCall ) | functionCall -> ^( GROUP_CONDITION functionCall ) | OPEN_BRACE expression ( AS var )? CLOSE_BRACE -> ^( GROUP_CONDITION expression ( ^( AS var ) )? ) | var -> ^( GROUP_CONDITION var ) )
 3268  70
             int alt28=4;
 3269  70
             switch ( input.LA(1) ) {
 3270  
             case ABS:
 3271  
             case BNODE:
 3272  
             case BOUND:
 3273  
             case CEIL:
 3274  
             case COALESCE:
 3275  
             case CONCAT:
 3276  
             case CONTAINS:
 3277  
             case DATATYPE:
 3278  
             case DAY:
 3279  
             case ENCODE_FOR_URI:
 3280  
             case EXISTS:
 3281  
             case FLOOR:
 3282  
             case HOURS:
 3283  
             case IF:
 3284  
             case IRI:
 3285  
             case ISBLANK:
 3286  
             case ISIRI:
 3287  
             case ISLITERAL:
 3288  
             case ISNUMERIC:
 3289  
             case ISURI:
 3290  
             case LANG:
 3291  
             case LANGMATCHES:
 3292  
             case LCASE:
 3293  
             case MD5:
 3294  
             case MINUTES:
 3295  
             case MONTH:
 3296  
             case NOT:
 3297  
             case NOW:
 3298  
             case RAND:
 3299  
             case REGEX:
 3300  
             case REPLACE:
 3301  
             case ROUND:
 3302  
             case SAMETERM:
 3303  
             case SECONDS:
 3304  
             case SHA1:
 3305  
             case SHA224:
 3306  
             case SHA256:
 3307  
             case SHA384:
 3308  
             case SHA512:
 3309  
             case STR:
 3310  
             case STRAFTER:
 3311  
             case STRBEFORE:
 3312  
             case STRDT:
 3313  
             case STRENDS:
 3314  
             case STRLANG:
 3315  
             case STRLEN:
 3316  
             case STRSTARTS:
 3317  
             case SUBSTR:
 3318  
             case TIMEZONE:
 3319  
             case TZ:
 3320  
             case UCASE:
 3321  
             case URI:
 3322  
             case YEAR:
 3323  
                 {
 3324  0
                 alt28=1;
 3325  
                 }
 3326  0
                 break;
 3327  
             case IRI_REF:
 3328  
             case PNAME_LN:
 3329  
             case PNAME_NS:
 3330  
                 {
 3331  0
                 alt28=2;
 3332  
                 }
 3333  0
                 break;
 3334  
             case OPEN_BRACE:
 3335  
                 {
 3336  12
                 alt28=3;
 3337  
                 }
 3338  12
                 break;
 3339  
             case VAR1:
 3340  
             case VAR2:
 3341  
                 {
 3342  58
                 alt28=4;
 3343  
                 }
 3344  58
                 break;
 3345  
             default:
 3346  0
                 NoViableAltException nvae =
 3347  
                     new NoViableAltException("", 28, 0, input);
 3348  
 
 3349  0
                 throw nvae;
 3350  
 
 3351  
             }
 3352  
 
 3353  70
             switch (alt28) {
 3354  
                 case 1 :
 3355  
                     // com\\googlecode\\sparkleg\\Sparql.g:142:7: builtInCall
 3356  
                     {
 3357  0
                     pushFollow(FOLLOW_builtInCall_in_groupCondition870);
 3358  0
                     builtInCall69=builtInCall();
 3359  
 
 3360  0
                     state._fsp--;
 3361  
 
 3362  0
                     stream_builtInCall.add(builtInCall69.getTree());
 3363  
 
 3364  
                     // AST REWRITE
 3365  
                     // elements: builtInCall
 3366  
                     // token labels: 
 3367  
                     // rule labels: retval
 3368  
                     // token list labels: 
 3369  
                     // rule list labels: 
 3370  
                     // wildcard labels: 
 3371  0
                     retval.tree = root_0;
 3372  0
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3373  
 
 3374  0
                     root_0 = (Object)adaptor.nil();
 3375  
                     // 142:19: -> ^( GROUP_CONDITION builtInCall )
 3376  
                     {
 3377  
                         // com\\googlecode\\sparkleg\\Sparql.g:142:22: ^( GROUP_CONDITION builtInCall )
 3378  
                         {
 3379  0
                         Object root_1 = (Object)adaptor.nil();
 3380  0
                         root_1 = (Object)adaptor.becomeRoot(
 3381  
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3382  
                         , root_1);
 3383  
 
 3384  0
                         adaptor.addChild(root_1, stream_builtInCall.nextTree());
 3385  
 
 3386  0
                         adaptor.addChild(root_0, root_1);
 3387  
                         }
 3388  
 
 3389  
                     }
 3390  
 
 3391  
 
 3392  0
                     retval.tree = root_0;
 3393  
 
 3394  
                     }
 3395  0
                     break;
 3396  
                 case 2 :
 3397  
                     // com\\googlecode\\sparkleg\\Sparql.g:143:7: functionCall
 3398  
                     {
 3399  0
                     pushFollow(FOLLOW_functionCall_in_groupCondition886);
 3400  0
                     functionCall70=functionCall();
 3401  
 
 3402  0
                     state._fsp--;
 3403  
 
 3404  0
                     stream_functionCall.add(functionCall70.getTree());
 3405  
 
 3406  
                     // AST REWRITE
 3407  
                     // elements: functionCall
 3408  
                     // token labels: 
 3409  
                     // rule labels: retval
 3410  
                     // token list labels: 
 3411  
                     // rule list labels: 
 3412  
                     // wildcard labels: 
 3413  0
                     retval.tree = root_0;
 3414  0
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3415  
 
 3416  0
                     root_0 = (Object)adaptor.nil();
 3417  
                     // 143:20: -> ^( GROUP_CONDITION functionCall )
 3418  
                     {
 3419  
                         // com\\googlecode\\sparkleg\\Sparql.g:143:23: ^( GROUP_CONDITION functionCall )
 3420  
                         {
 3421  0
                         Object root_1 = (Object)adaptor.nil();
 3422  0
                         root_1 = (Object)adaptor.becomeRoot(
 3423  
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3424  
                         , root_1);
 3425  
 
 3426  0
                         adaptor.addChild(root_1, stream_functionCall.nextTree());
 3427  
 
 3428  0
                         adaptor.addChild(root_0, root_1);
 3429  
                         }
 3430  
 
 3431  
                     }
 3432  
 
 3433  
 
 3434  0
                     retval.tree = root_0;
 3435  
 
 3436  
                     }
 3437  0
                     break;
 3438  
                 case 3 :
 3439  
                     // com\\googlecode\\sparkleg\\Sparql.g:144:7: OPEN_BRACE expression ( AS var )? CLOSE_BRACE
 3440  
                     {
 3441  12
                     OPEN_BRACE71=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_groupCondition902);  
 3442  12
                     stream_OPEN_BRACE.add(OPEN_BRACE71);
 3443  
 
 3444  
 
 3445  12
                     pushFollow(FOLLOW_expression_in_groupCondition904);
 3446  12
                     expression72=expression();
 3447  
 
 3448  12
                     state._fsp--;
 3449  
 
 3450  12
                     stream_expression.add(expression72.getTree());
 3451  
 
 3452  
                     // com\\googlecode\\sparkleg\\Sparql.g:144:29: ( AS var )?
 3453  12
                     int alt27=2;
 3454  12
                     switch ( input.LA(1) ) {
 3455  
                         case AS:
 3456  
                             {
 3457  4
                             alt27=1;
 3458  
                             }
 3459  
                             break;
 3460  
                     }
 3461  
 
 3462  12
                     switch (alt27) {
 3463  
                         case 1 :
 3464  
                             // com\\googlecode\\sparkleg\\Sparql.g:144:30: AS var
 3465  
                             {
 3466  4
                             AS73=(Token)match(input,AS,FOLLOW_AS_in_groupCondition907);  
 3467  4
                             stream_AS.add(AS73);
 3468  
 
 3469  
 
 3470  4
                             pushFollow(FOLLOW_var_in_groupCondition909);
 3471  4
                             var74=var();
 3472  
 
 3473  4
                             state._fsp--;
 3474  
 
 3475  4
                             stream_var.add(var74.getTree());
 3476  
 
 3477  
                             }
 3478  
                             break;
 3479  
 
 3480  
                     }
 3481  
 
 3482  
 
 3483  12
                     CLOSE_BRACE75=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_groupCondition913);  
 3484  12
                     stream_CLOSE_BRACE.add(CLOSE_BRACE75);
 3485  
 
 3486  
 
 3487  
                     // AST REWRITE
 3488  
                     // elements: expression, AS, var
 3489  
                     // token labels: 
 3490  
                     // rule labels: retval
 3491  
                     // token list labels: 
 3492  
                     // rule list labels: 
 3493  
                     // wildcard labels: 
 3494  12
                     retval.tree = root_0;
 3495  12
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3496  
 
 3497  12
                     root_0 = (Object)adaptor.nil();
 3498  
                     // 144:51: -> ^( GROUP_CONDITION expression ( ^( AS var ) )? )
 3499  
                     {
 3500  
                         // com\\googlecode\\sparkleg\\Sparql.g:144:54: ^( GROUP_CONDITION expression ( ^( AS var ) )? )
 3501  
                         {
 3502  12
                         Object root_1 = (Object)adaptor.nil();
 3503  12
                         root_1 = (Object)adaptor.becomeRoot(
 3504  
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3505  
                         , root_1);
 3506  
 
 3507  12
                         adaptor.addChild(root_1, stream_expression.nextTree());
 3508  
 
 3509  
                         // com\\googlecode\\sparkleg\\Sparql.g:144:83: ( ^( AS var ) )?
 3510  12
                         if ( stream_AS.hasNext()||stream_var.hasNext() ) {
 3511  
                             // com\\googlecode\\sparkleg\\Sparql.g:144:83: ^( AS var )
 3512  
                             {
 3513  4
                             Object root_2 = (Object)adaptor.nil();
 3514  4
                             root_2 = (Object)adaptor.becomeRoot(
 3515  
                             stream_AS.nextNode()
 3516  
                             , root_2);
 3517  
 
 3518  4
                             adaptor.addChild(root_2, stream_var.nextTree());
 3519  
 
 3520  4
                             adaptor.addChild(root_1, root_2);
 3521  
                             }
 3522  
 
 3523  
                         }
 3524  12
                         stream_AS.reset();
 3525  12
                         stream_var.reset();
 3526  
 
 3527  12
                         adaptor.addChild(root_0, root_1);
 3528  
                         }
 3529  
 
 3530  
                     }
 3531  
 
 3532  
 
 3533  12
                     retval.tree = root_0;
 3534  
 
 3535  
                     }
 3536  12
                     break;
 3537  
                 case 4 :
 3538  
                     // com\\googlecode\\sparkleg\\Sparql.g:145:7: var
 3539  
                     {
 3540  58
                     pushFollow(FOLLOW_var_in_groupCondition937);
 3541  58
                     var76=var();
 3542  
 
 3543  58
                     state._fsp--;
 3544  
 
 3545  58
                     stream_var.add(var76.getTree());
 3546  
 
 3547  
                     // AST REWRITE
 3548  
                     // elements: var
 3549  
                     // token labels: 
 3550  
                     // rule labels: retval
 3551  
                     // token list labels: 
 3552  
                     // rule list labels: 
 3553  
                     // wildcard labels: 
 3554  58
                     retval.tree = root_0;
 3555  58
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3556  
 
 3557  58
                     root_0 = (Object)adaptor.nil();
 3558  
                     // 145:11: -> ^( GROUP_CONDITION var )
 3559  
                     {
 3560  
                         // com\\googlecode\\sparkleg\\Sparql.g:145:14: ^( GROUP_CONDITION var )
 3561  
                         {
 3562  58
                         Object root_1 = (Object)adaptor.nil();
 3563  58
                         root_1 = (Object)adaptor.becomeRoot(
 3564  
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3565  
                         , root_1);
 3566  
 
 3567  58
                         adaptor.addChild(root_1, stream_var.nextTree());
 3568  
 
 3569  58
                         adaptor.addChild(root_0, root_1);
 3570  
                         }
 3571  
 
 3572  
                     }
 3573  
 
 3574  
 
 3575  58
                     retval.tree = root_0;
 3576  
 
 3577  
                     }
 3578  
                     break;
 3579  
 
 3580  
             }
 3581  70
             retval.stop = input.LT(-1);
 3582  
 
 3583  
 
 3584  70
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3585  70
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3586  
 
 3587  
         }
 3588  0
         catch (RecognitionException re) {
 3589  0
             reportError(re);
 3590  0
             recover(input,re);
 3591  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3592  
 
 3593  
         }
 3594  
 
 3595  0
         finally {
 3596  
                 // do for sure before leaving
 3597  70
         }
 3598  70
         return retval;
 3599  
     }
 3600  
     // $ANTLR end "groupCondition"
 3601  
 
 3602  
 
 3603  16
     public static class havingClause_return extends ParserRuleReturnScope {
 3604  
         Object tree;
 3605  16
         public Object getTree() { return tree; }
 3606  
     };
 3607  
 
 3608  
 
 3609  
     // $ANTLR start "havingClause"
 3610  
     // com\\googlecode\\sparkleg\\Sparql.g:148:1: havingClause : HAVING ( constraint )+ -> ^( HAVING ( constraint )+ ) ;
 3611  
     public final SparqlParser.havingClause_return havingClause() throws RecognitionException {
 3612  16
         SparqlParser.havingClause_return retval = new SparqlParser.havingClause_return();
 3613  16
         retval.start = input.LT(1);
 3614  
 
 3615  
 
 3616  16
         Object root_0 = null;
 3617  
 
 3618  16
         Token HAVING77=null;
 3619  16
         SparqlParser.constraint_return constraint78 =null;
 3620  
 
 3621  
 
 3622  16
         Object HAVING77_tree=null;
 3623  16
         RewriteRuleTokenStream stream_HAVING=new RewriteRuleTokenStream(adaptor,"token HAVING");
 3624  16
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 3625  
         try {
 3626  
             // com\\googlecode\\sparkleg\\Sparql.g:149:5: ( HAVING ( constraint )+ -> ^( HAVING ( constraint )+ ) )
 3627  
             // com\\googlecode\\sparkleg\\Sparql.g:149:7: HAVING ( constraint )+
 3628  
             {
 3629  16
             HAVING77=(Token)match(input,HAVING,FOLLOW_HAVING_in_havingClause966);  
 3630  16
             stream_HAVING.add(HAVING77);
 3631  
 
 3632  
 
 3633  
             // com\\googlecode\\sparkleg\\Sparql.g:149:14: ( constraint )+
 3634  16
             int cnt29=0;
 3635  
             loop29:
 3636  
             do {
 3637  32
                 int alt29=2;
 3638  32
                 switch ( input.LA(1) ) {
 3639  
                 case ABS:
 3640  
                 case BNODE:
 3641  
                 case BOUND:
 3642  
                 case CEIL:
 3643  
                 case COALESCE:
 3644  
                 case CONCAT:
 3645  
                 case CONTAINS:
 3646  
                 case DATATYPE:
 3647  
                 case DAY:
 3648  
                 case ENCODE_FOR_URI:
 3649  
                 case EXISTS:
 3650  
                 case FLOOR:
 3651  
                 case HOURS:
 3652  
                 case IF:
 3653  
                 case IRI:
 3654  
                 case IRI_REF:
 3655  
                 case ISBLANK:
 3656  
                 case ISIRI:
 3657  
                 case ISLITERAL:
 3658  
                 case ISNUMERIC:
 3659  
                 case ISURI:
 3660  
                 case LANG:
 3661  
                 case LANGMATCHES:
 3662  
                 case LCASE:
 3663  
                 case MD5:
 3664  
                 case MINUTES:
 3665  
                 case MONTH:
 3666  
                 case NOT:
 3667  
                 case NOW:
 3668  
                 case OPEN_BRACE:
 3669  
                 case PNAME_LN:
 3670  
                 case PNAME_NS:
 3671  
                 case RAND:
 3672  
                 case REGEX:
 3673  
                 case REPLACE:
 3674  
                 case ROUND:
 3675  
                 case SAMETERM:
 3676  
                 case SECONDS:
 3677  
                 case SHA1:
 3678  
                 case SHA224:
 3679  
                 case SHA256:
 3680  
                 case SHA384:
 3681  
                 case SHA512:
 3682  
                 case STR:
 3683  
                 case STRAFTER:
 3684  
                 case STRBEFORE:
 3685  
                 case STRDT:
 3686  
                 case STRENDS:
 3687  
                 case STRLANG:
 3688  
                 case STRLEN:
 3689  
                 case STRSTARTS:
 3690  
                 case SUBSTR:
 3691  
                 case TIMEZONE:
 3692  
                 case TZ:
 3693  
                 case UCASE:
 3694  
                 case URI:
 3695  
                 case YEAR:
 3696  
                     {
 3697  16
                     alt29=1;
 3698  
                     }
 3699  
                     break;
 3700  
 
 3701  
                 }
 3702  
 
 3703  32
                 switch (alt29) {
 3704  
                     case 1 :
 3705  
                         // com\\googlecode\\sparkleg\\Sparql.g:149:14: constraint
 3706  
                         {
 3707  16
                         pushFollow(FOLLOW_constraint_in_havingClause968);
 3708  16
                         constraint78=constraint();
 3709  
 
 3710  16
                         state._fsp--;
 3711  
 
 3712  16
                         stream_constraint.add(constraint78.getTree());
 3713  
 
 3714  
                         }
 3715  16
                         break;
 3716  
 
 3717  
                     default :
 3718  16
                         if ( cnt29 >= 1 ) break loop29;
 3719  0
                         EarlyExitException eee =
 3720  
                             new EarlyExitException(29, input);
 3721  0
                         throw eee;
 3722  
                 }
 3723  16
                 cnt29++;
 3724  16
             } while (true);
 3725  
 
 3726  
 
 3727  
             // AST REWRITE
 3728  
             // elements: HAVING, constraint
 3729  
             // token labels: 
 3730  
             // rule labels: retval
 3731  
             // token list labels: 
 3732  
             // rule list labels: 
 3733  
             // wildcard labels: 
 3734  16
             retval.tree = root_0;
 3735  16
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3736  
 
 3737  16
             root_0 = (Object)adaptor.nil();
 3738  
             // 149:26: -> ^( HAVING ( constraint )+ )
 3739  
             {
 3740  
                 // com\\googlecode\\sparkleg\\Sparql.g:149:29: ^( HAVING ( constraint )+ )
 3741  
                 {
 3742  16
                 Object root_1 = (Object)adaptor.nil();
 3743  16
                 root_1 = (Object)adaptor.becomeRoot(
 3744  
                 stream_HAVING.nextNode()
 3745  
                 , root_1);
 3746  
 
 3747  16
                 if ( !(stream_constraint.hasNext()) ) {
 3748  0
                     throw new RewriteEarlyExitException();
 3749  
                 }
 3750  32
                 while ( stream_constraint.hasNext() ) {
 3751  16
                     adaptor.addChild(root_1, stream_constraint.nextTree());
 3752  
 
 3753  
                 }
 3754  16
                 stream_constraint.reset();
 3755  
 
 3756  16
                 adaptor.addChild(root_0, root_1);
 3757  
                 }
 3758  
 
 3759  
             }
 3760  
 
 3761  
 
 3762  16
             retval.tree = root_0;
 3763  
 
 3764  
             }
 3765  
 
 3766  16
             retval.stop = input.LT(-1);
 3767  
 
 3768  
 
 3769  16
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3770  16
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3771  
 
 3772  
         }
 3773  0
         catch (RecognitionException re) {
 3774  0
             reportError(re);
 3775  0
             recover(input,re);
 3776  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3777  
 
 3778  
         }
 3779  
 
 3780  0
         finally {
 3781  
                 // do for sure before leaving
 3782  16
         }
 3783  16
         return retval;
 3784  
     }
 3785  
     // $ANTLR end "havingClause"
 3786  
 
 3787  
 
 3788  134
     public static class orderClause_return extends ParserRuleReturnScope {
 3789  
         Object tree;
 3790  134
         public Object getTree() { return tree; }
 3791  
     };
 3792  
 
 3793  
 
 3794  
     // $ANTLR start "orderClause"
 3795  
     // com\\googlecode\\sparkleg\\Sparql.g:152:1: orderClause : ORDER BY ( orderCondition )+ -> ^( ORDER_BY ( orderCondition )+ ) ;
 3796  
     public final SparqlParser.orderClause_return orderClause() throws RecognitionException {
 3797  134
         SparqlParser.orderClause_return retval = new SparqlParser.orderClause_return();
 3798  134
         retval.start = input.LT(1);
 3799  
 
 3800  
 
 3801  134
         Object root_0 = null;
 3802  
 
 3803  134
         Token ORDER79=null;
 3804  134
         Token BY80=null;
 3805  134
         SparqlParser.orderCondition_return orderCondition81 =null;
 3806  
 
 3807  
 
 3808  134
         Object ORDER79_tree=null;
 3809  134
         Object BY80_tree=null;
 3810  134
         RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
 3811  134
         RewriteRuleTokenStream stream_ORDER=new RewriteRuleTokenStream(adaptor,"token ORDER");
 3812  134
         RewriteRuleSubtreeStream stream_orderCondition=new RewriteRuleSubtreeStream(adaptor,"rule orderCondition");
 3813  
         try {
 3814  
             // com\\googlecode\\sparkleg\\Sparql.g:153:5: ( ORDER BY ( orderCondition )+ -> ^( ORDER_BY ( orderCondition )+ ) )
 3815  
             // com\\googlecode\\sparkleg\\Sparql.g:153:7: ORDER BY ( orderCondition )+
 3816  
             {
 3817  134
             ORDER79=(Token)match(input,ORDER,FOLLOW_ORDER_in_orderClause1000);  
 3818  134
             stream_ORDER.add(ORDER79);
 3819  
 
 3820  
 
 3821  134
             BY80=(Token)match(input,BY,FOLLOW_BY_in_orderClause1002);  
 3822  134
             stream_BY.add(BY80);
 3823  
 
 3824  
 
 3825  
             // com\\googlecode\\sparkleg\\Sparql.g:153:16: ( orderCondition )+
 3826  134
             int cnt30=0;
 3827  
             loop30:
 3828  
             do {
 3829  316
                 int alt30=2;
 3830  316
                 switch ( input.LA(1) ) {
 3831  
                 case ABS:
 3832  
                 case ASC:
 3833  
                 case BNODE:
 3834  
                 case BOUND:
 3835  
                 case CEIL:
 3836  
                 case COALESCE:
 3837  
                 case CONCAT:
 3838  
                 case CONTAINS:
 3839  
                 case DATATYPE:
 3840  
                 case DAY:
 3841  
                 case DESC:
 3842  
                 case ENCODE_FOR_URI:
 3843  
                 case EXISTS:
 3844  
                 case FLOOR:
 3845  
                 case HOURS:
 3846  
                 case IF:
 3847  
                 case IRI:
 3848  
                 case IRI_REF:
 3849  
                 case ISBLANK:
 3850  
                 case ISIRI:
 3851  
                 case ISLITERAL:
 3852  
                 case ISNUMERIC:
 3853  
                 case ISURI:
 3854  
                 case LANG:
 3855  
                 case LANGMATCHES:
 3856  
                 case LCASE:
 3857  
                 case MD5:
 3858  
                 case MINUTES:
 3859  
                 case MONTH:
 3860  
                 case NOT:
 3861  
                 case NOW:
 3862  
                 case OPEN_BRACE:
 3863  
                 case PNAME_LN:
 3864  
                 case PNAME_NS:
 3865  
                 case RAND:
 3866  
                 case REGEX:
 3867  
                 case REPLACE:
 3868  
                 case ROUND:
 3869  
                 case SAMETERM:
 3870  
                 case SECONDS:
 3871  
                 case SHA1:
 3872  
                 case SHA224:
 3873  
                 case SHA256:
 3874  
                 case SHA384:
 3875  
                 case SHA512:
 3876  
                 case STR:
 3877  
                 case STRAFTER:
 3878  
                 case STRBEFORE:
 3879  
                 case STRDT:
 3880  
                 case STRENDS:
 3881  
                 case STRLANG:
 3882  
                 case STRLEN:
 3883  
                 case STRSTARTS:
 3884  
                 case SUBSTR:
 3885  
                 case TIMEZONE:
 3886  
                 case TZ:
 3887  
                 case UCASE:
 3888  
                 case URI:
 3889  
                 case VAR1:
 3890  
                 case VAR2:
 3891  
                 case YEAR:
 3892  
                     {
 3893  182
                     alt30=1;
 3894  
                     }
 3895  
                     break;
 3896  
 
 3897  
                 }
 3898  
 
 3899  316
                 switch (alt30) {
 3900  
                     case 1 :
 3901  
                         // com\\googlecode\\sparkleg\\Sparql.g:153:16: orderCondition
 3902  
                         {
 3903  182
                         pushFollow(FOLLOW_orderCondition_in_orderClause1004);
 3904  182
                         orderCondition81=orderCondition();
 3905  
 
 3906  182
                         state._fsp--;
 3907  
 
 3908  182
                         stream_orderCondition.add(orderCondition81.getTree());
 3909  
 
 3910  
                         }
 3911  182
                         break;
 3912  
 
 3913  
                     default :
 3914  134
                         if ( cnt30 >= 1 ) break loop30;
 3915  0
                         EarlyExitException eee =
 3916  
                             new EarlyExitException(30, input);
 3917  0
                         throw eee;
 3918  
                 }
 3919  182
                 cnt30++;
 3920  182
             } while (true);
 3921  
 
 3922  
 
 3923  
             // AST REWRITE
 3924  
             // elements: orderCondition
 3925  
             // token labels: 
 3926  
             // rule labels: retval
 3927  
             // token list labels: 
 3928  
             // rule list labels: 
 3929  
             // wildcard labels: 
 3930  134
             retval.tree = root_0;
 3931  134
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3932  
 
 3933  134
             root_0 = (Object)adaptor.nil();
 3934  
             // 153:32: -> ^( ORDER_BY ( orderCondition )+ )
 3935  
             {
 3936  
                 // com\\googlecode\\sparkleg\\Sparql.g:153:35: ^( ORDER_BY ( orderCondition )+ )
 3937  
                 {
 3938  134
                 Object root_1 = (Object)adaptor.nil();
 3939  134
                 root_1 = (Object)adaptor.becomeRoot(
 3940  
                 (Object)adaptor.create(ORDER_BY, "ORDER_BY")
 3941  
                 , root_1);
 3942  
 
 3943  134
                 if ( !(stream_orderCondition.hasNext()) ) {
 3944  0
                     throw new RewriteEarlyExitException();
 3945  
                 }
 3946  316
                 while ( stream_orderCondition.hasNext() ) {
 3947  182
                     adaptor.addChild(root_1, stream_orderCondition.nextTree());
 3948  
 
 3949  
                 }
 3950  134
                 stream_orderCondition.reset();
 3951  
 
 3952  134
                 adaptor.addChild(root_0, root_1);
 3953  
                 }
 3954  
 
 3955  
             }
 3956  
 
 3957  
 
 3958  134
             retval.tree = root_0;
 3959  
 
 3960  
             }
 3961  
 
 3962  134
             retval.stop = input.LT(-1);
 3963  
 
 3964  
 
 3965  134
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3966  134
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3967  
 
 3968  
         }
 3969  0
         catch (RecognitionException re) {
 3970  0
             reportError(re);
 3971  0
             recover(input,re);
 3972  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3973  
 
 3974  
         }
 3975  
 
 3976  0
         finally {
 3977  
                 // do for sure before leaving
 3978  134
         }
 3979  134
         return retval;
 3980  
     }
 3981  
     // $ANTLR end "orderClause"
 3982  
 
 3983  
 
 3984  182
     public static class orderCondition_return extends ParserRuleReturnScope {
 3985  
         Object tree;
 3986  182
         public Object getTree() { return tree; }
 3987  
     };
 3988  
 
 3989  
 
 3990  
     // $ANTLR start "orderCondition"
 3991  
     // com\\googlecode\\sparkleg\\Sparql.g:156:1: orderCondition : ( ASC brackettedExpression -> ^( ORDER_CONDITION ASC brackettedExpression ) | DESC brackettedExpression -> ^( ORDER_CONDITION DESC brackettedExpression ) | constraint -> ^( ORDER_CONDITION constraint ) | var -> ^( ORDER_CONDITION var ) );
 3992  
     public final SparqlParser.orderCondition_return orderCondition() throws RecognitionException {
 3993  182
         SparqlParser.orderCondition_return retval = new SparqlParser.orderCondition_return();
 3994  182
         retval.start = input.LT(1);
 3995  
 
 3996  
 
 3997  182
         Object root_0 = null;
 3998  
 
 3999  182
         Token ASC82=null;
 4000  182
         Token DESC84=null;
 4001  182
         SparqlParser.brackettedExpression_return brackettedExpression83 =null;
 4002  
 
 4003  182
         SparqlParser.brackettedExpression_return brackettedExpression85 =null;
 4004  
 
 4005  182
         SparqlParser.constraint_return constraint86 =null;
 4006  
 
 4007  182
         SparqlParser.var_return var87 =null;
 4008  
 
 4009  
 
 4010  182
         Object ASC82_tree=null;
 4011  182
         Object DESC84_tree=null;
 4012  182
         RewriteRuleTokenStream stream_DESC=new RewriteRuleTokenStream(adaptor,"token DESC");
 4013  182
         RewriteRuleTokenStream stream_ASC=new RewriteRuleTokenStream(adaptor,"token ASC");
 4014  182
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 4015  182
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 4016  182
         RewriteRuleSubtreeStream stream_brackettedExpression=new RewriteRuleSubtreeStream(adaptor,"rule brackettedExpression");
 4017  
         try {
 4018  
             // com\\googlecode\\sparkleg\\Sparql.g:157:5: ( ASC brackettedExpression -> ^( ORDER_CONDITION ASC brackettedExpression ) | DESC brackettedExpression -> ^( ORDER_CONDITION DESC brackettedExpression ) | constraint -> ^( ORDER_CONDITION constraint ) | var -> ^( ORDER_CONDITION var ) )
 4019  182
             int alt31=4;
 4020  182
             switch ( input.LA(1) ) {
 4021  
             case ASC:
 4022  
                 {
 4023  10
                 alt31=1;
 4024  
                 }
 4025  10
                 break;
 4026  
             case DESC:
 4027  
                 {
 4028  30
                 alt31=2;
 4029  
                 }
 4030  30
                 break;
 4031  
             case ABS:
 4032  
             case BNODE:
 4033  
             case BOUND:
 4034  
             case CEIL:
 4035  
             case COALESCE:
 4036  
             case CONCAT:
 4037  
             case CONTAINS:
 4038  
             case DATATYPE:
 4039  
             case DAY:
 4040  
             case ENCODE_FOR_URI:
 4041  
             case EXISTS:
 4042  
             case FLOOR:
 4043  
             case HOURS:
 4044  
             case IF:
 4045  
             case IRI:
 4046  
             case IRI_REF:
 4047  
             case ISBLANK:
 4048  
             case ISIRI:
 4049  
             case ISLITERAL:
 4050  
             case ISNUMERIC:
 4051  
             case ISURI:
 4052  
             case LANG:
 4053  
             case LANGMATCHES:
 4054  
             case LCASE:
 4055  
             case MD5:
 4056  
             case MINUTES:
 4057  
             case MONTH:
 4058  
             case NOT:
 4059  
             case NOW:
 4060  
             case OPEN_BRACE:
 4061  
             case PNAME_LN:
 4062  
             case PNAME_NS:
 4063  
             case RAND:
 4064  
             case REGEX:
 4065  
             case REPLACE:
 4066  
             case ROUND:
 4067  
             case SAMETERM:
 4068  
             case SECONDS:
 4069  
             case SHA1:
 4070  
             case SHA224:
 4071  
             case SHA256:
 4072  
             case SHA384:
 4073  
             case SHA512:
 4074  
             case STR:
 4075  
             case STRAFTER:
 4076  
             case STRBEFORE:
 4077  
             case STRDT:
 4078  
             case STRENDS:
 4079  
             case STRLANG:
 4080  
             case STRLEN:
 4081  
             case STRSTARTS:
 4082  
             case SUBSTR:
 4083  
             case TIMEZONE:
 4084  
             case TZ:
 4085  
             case UCASE:
 4086  
             case URI:
 4087  
             case YEAR:
 4088  
                 {
 4089  12
                 alt31=3;
 4090  
                 }
 4091  12
                 break;
 4092  
             case VAR1:
 4093  
             case VAR2:
 4094  
                 {
 4095  130
                 alt31=4;
 4096  
                 }
 4097  130
                 break;
 4098  
             default:
 4099  0
                 NoViableAltException nvae =
 4100  
                     new NoViableAltException("", 31, 0, input);
 4101  
 
 4102  0
                 throw nvae;
 4103  
 
 4104  
             }
 4105  
 
 4106  182
             switch (alt31) {
 4107  
                 case 1 :
 4108  
                     // com\\googlecode\\sparkleg\\Sparql.g:157:7: ASC brackettedExpression
 4109  
                     {
 4110  10
                     ASC82=(Token)match(input,ASC,FOLLOW_ASC_in_orderCondition1031);  
 4111  10
                     stream_ASC.add(ASC82);
 4112  
 
 4113  
 
 4114  10
                     pushFollow(FOLLOW_brackettedExpression_in_orderCondition1033);
 4115  10
                     brackettedExpression83=brackettedExpression();
 4116  
 
 4117  10
                     state._fsp--;
 4118  
 
 4119  10
                     stream_brackettedExpression.add(brackettedExpression83.getTree());
 4120  
 
 4121  
                     // AST REWRITE
 4122  
                     // elements: ASC, brackettedExpression
 4123  
                     // token labels: 
 4124  
                     // rule labels: retval
 4125  
                     // token list labels: 
 4126  
                     // rule list labels: 
 4127  
                     // wildcard labels: 
 4128  10
                     retval.tree = root_0;
 4129  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4130  
 
 4131  10
                     root_0 = (Object)adaptor.nil();
 4132  
                     // 157:32: -> ^( ORDER_CONDITION ASC brackettedExpression )
 4133  
                     {
 4134  
                         // com\\googlecode\\sparkleg\\Sparql.g:157:35: ^( ORDER_CONDITION ASC brackettedExpression )
 4135  
                         {
 4136  10
                         Object root_1 = (Object)adaptor.nil();
 4137  10
                         root_1 = (Object)adaptor.becomeRoot(
 4138  
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4139  
                         , root_1);
 4140  
 
 4141  10
                         adaptor.addChild(root_1, 
 4142  
                         stream_ASC.nextNode()
 4143  
                         );
 4144  
 
 4145  10
                         adaptor.addChild(root_1, stream_brackettedExpression.nextTree());
 4146  
 
 4147  10
                         adaptor.addChild(root_0, root_1);
 4148  
                         }
 4149  
 
 4150  
                     }
 4151  
 
 4152  
 
 4153  10
                     retval.tree = root_0;
 4154  
 
 4155  
                     }
 4156  10
                     break;
 4157  
                 case 2 :
 4158  
                     // com\\googlecode\\sparkleg\\Sparql.g:158:7: DESC brackettedExpression
 4159  
                     {
 4160  30
                     DESC84=(Token)match(input,DESC,FOLLOW_DESC_in_orderCondition1051);  
 4161  30
                     stream_DESC.add(DESC84);
 4162  
 
 4163  
 
 4164  30
                     pushFollow(FOLLOW_brackettedExpression_in_orderCondition1053);
 4165  30
                     brackettedExpression85=brackettedExpression();
 4166  
 
 4167  30
                     state._fsp--;
 4168  
 
 4169  30
                     stream_brackettedExpression.add(brackettedExpression85.getTree());
 4170  
 
 4171  
                     // AST REWRITE
 4172  
                     // elements: brackettedExpression, DESC
 4173  
                     // token labels: 
 4174  
                     // rule labels: retval
 4175  
                     // token list labels: 
 4176  
                     // rule list labels: 
 4177  
                     // wildcard labels: 
 4178  30
                     retval.tree = root_0;
 4179  30
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4180  
 
 4181  30
                     root_0 = (Object)adaptor.nil();
 4182  
                     // 158:33: -> ^( ORDER_CONDITION DESC brackettedExpression )
 4183  
                     {
 4184  
                         // com\\googlecode\\sparkleg\\Sparql.g:158:36: ^( ORDER_CONDITION DESC brackettedExpression )
 4185  
                         {
 4186  30
                         Object root_1 = (Object)adaptor.nil();
 4187  30
                         root_1 = (Object)adaptor.becomeRoot(
 4188  
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4189  
                         , root_1);
 4190  
 
 4191  30
                         adaptor.addChild(root_1, 
 4192  
                         stream_DESC.nextNode()
 4193  
                         );
 4194  
 
 4195  30
                         adaptor.addChild(root_1, stream_brackettedExpression.nextTree());
 4196  
 
 4197  30
                         adaptor.addChild(root_0, root_1);
 4198  
                         }
 4199  
 
 4200  
                     }
 4201  
 
 4202  
 
 4203  30
                     retval.tree = root_0;
 4204  
 
 4205  
                     }
 4206  30
                     break;
 4207  
                 case 3 :
 4208  
                     // com\\googlecode\\sparkleg\\Sparql.g:159:7: constraint
 4209  
                     {
 4210  12
                     pushFollow(FOLLOW_constraint_in_orderCondition1071);
 4211  12
                     constraint86=constraint();
 4212  
 
 4213  12
                     state._fsp--;
 4214  
 
 4215  12
                     stream_constraint.add(constraint86.getTree());
 4216  
 
 4217  
                     // AST REWRITE
 4218  
                     // elements: constraint
 4219  
                     // token labels: 
 4220  
                     // rule labels: retval
 4221  
                     // token list labels: 
 4222  
                     // rule list labels: 
 4223  
                     // wildcard labels: 
 4224  12
                     retval.tree = root_0;
 4225  12
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4226  
 
 4227  12
                     root_0 = (Object)adaptor.nil();
 4228  
                     // 159:18: -> ^( ORDER_CONDITION constraint )
 4229  
                     {
 4230  
                         // com\\googlecode\\sparkleg\\Sparql.g:159:21: ^( ORDER_CONDITION constraint )
 4231  
                         {
 4232  12
                         Object root_1 = (Object)adaptor.nil();
 4233  12
                         root_1 = (Object)adaptor.becomeRoot(
 4234  
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4235  
                         , root_1);
 4236  
 
 4237  12
                         adaptor.addChild(root_1, stream_constraint.nextTree());
 4238  
 
 4239  12
                         adaptor.addChild(root_0, root_1);
 4240  
                         }
 4241  
 
 4242  
                     }
 4243  
 
 4244  
 
 4245  12
                     retval.tree = root_0;
 4246  
 
 4247  
                     }
 4248  12
                     break;
 4249  
                 case 4 :
 4250  
                     // com\\googlecode\\sparkleg\\Sparql.g:160:7: var
 4251  
                     {
 4252  130
                     pushFollow(FOLLOW_var_in_orderCondition1087);
 4253  130
                     var87=var();
 4254  
 
 4255  130
                     state._fsp--;
 4256  
 
 4257  130
                     stream_var.add(var87.getTree());
 4258  
 
 4259  
                     // AST REWRITE
 4260  
                     // elements: var
 4261  
                     // token labels: 
 4262  
                     // rule labels: retval
 4263  
                     // token list labels: 
 4264  
                     // rule list labels: 
 4265  
                     // wildcard labels: 
 4266  130
                     retval.tree = root_0;
 4267  130
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4268  
 
 4269  130
                     root_0 = (Object)adaptor.nil();
 4270  
                     // 160:11: -> ^( ORDER_CONDITION var )
 4271  
                     {
 4272  
                         // com\\googlecode\\sparkleg\\Sparql.g:160:14: ^( ORDER_CONDITION var )
 4273  
                         {
 4274  130
                         Object root_1 = (Object)adaptor.nil();
 4275  130
                         root_1 = (Object)adaptor.becomeRoot(
 4276  
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4277  
                         , root_1);
 4278  
 
 4279  130
                         adaptor.addChild(root_1, stream_var.nextTree());
 4280  
 
 4281  130
                         adaptor.addChild(root_0, root_1);
 4282  
                         }
 4283  
 
 4284  
                     }
 4285  
 
 4286  
 
 4287  130
                     retval.tree = root_0;
 4288  
 
 4289  
                     }
 4290  
                     break;
 4291  
 
 4292  
             }
 4293  182
             retval.stop = input.LT(-1);
 4294  
 
 4295  
 
 4296  182
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4297  182
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4298  
 
 4299  
         }
 4300  0
         catch (RecognitionException re) {
 4301  0
             reportError(re);
 4302  0
             recover(input,re);
 4303  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4304  
 
 4305  
         }
 4306  
 
 4307  0
         finally {
 4308  
                 // do for sure before leaving
 4309  182
         }
 4310  182
         return retval;
 4311  
     }
 4312  
     // $ANTLR end "orderCondition"
 4313  
 
 4314  
 
 4315  58
     public static class limitOffsetClauses_return extends ParserRuleReturnScope {
 4316  
         Object tree;
 4317  58
         public Object getTree() { return tree; }
 4318  
     };
 4319  
 
 4320  
 
 4321  
     // $ANTLR start "limitOffsetClauses"
 4322  
     // com\\googlecode\\sparkleg\\Sparql.g:163:1: limitOffsetClauses : ( limitClause ( offsetClause )? -> limitClause ( offsetClause )* | offsetClause ( limitClause )? -> offsetClause ( limitClause )* );
 4323  
     public final SparqlParser.limitOffsetClauses_return limitOffsetClauses() throws RecognitionException {
 4324  58
         SparqlParser.limitOffsetClauses_return retval = new SparqlParser.limitOffsetClauses_return();
 4325  58
         retval.start = input.LT(1);
 4326  
 
 4327  
 
 4328  58
         Object root_0 = null;
 4329  
 
 4330  58
         SparqlParser.limitClause_return limitClause88 =null;
 4331  
 
 4332  58
         SparqlParser.offsetClause_return offsetClause89 =null;
 4333  
 
 4334  58
         SparqlParser.offsetClause_return offsetClause90 =null;
 4335  
 
 4336  58
         SparqlParser.limitClause_return limitClause91 =null;
 4337  
 
 4338  
 
 4339  58
         RewriteRuleSubtreeStream stream_offsetClause=new RewriteRuleSubtreeStream(adaptor,"rule offsetClause");
 4340  58
         RewriteRuleSubtreeStream stream_limitClause=new RewriteRuleSubtreeStream(adaptor,"rule limitClause");
 4341  
         try {
 4342  
             // com\\googlecode\\sparkleg\\Sparql.g:164:5: ( limitClause ( offsetClause )? -> limitClause ( offsetClause )* | offsetClause ( limitClause )? -> offsetClause ( limitClause )* )
 4343  58
             int alt34=2;
 4344  58
             switch ( input.LA(1) ) {
 4345  
             case LIMIT:
 4346  
                 {
 4347  38
                 alt34=1;
 4348  
                 }
 4349  38
                 break;
 4350  
             case OFFSET:
 4351  
                 {
 4352  20
                 alt34=2;
 4353  
                 }
 4354  20
                 break;
 4355  
             default:
 4356  0
                 NoViableAltException nvae =
 4357  
                     new NoViableAltException("", 34, 0, input);
 4358  
 
 4359  0
                 throw nvae;
 4360  
 
 4361  
             }
 4362  
 
 4363  58
             switch (alt34) {
 4364  
                 case 1 :
 4365  
                     // com\\googlecode\\sparkleg\\Sparql.g:164:7: limitClause ( offsetClause )?
 4366  
                     {
 4367  38
                     pushFollow(FOLLOW_limitClause_in_limitOffsetClauses1117);
 4368  38
                     limitClause88=limitClause();
 4369  
 
 4370  38
                     state._fsp--;
 4371  
 
 4372  38
                     stream_limitClause.add(limitClause88.getTree());
 4373  
 
 4374  
                     // com\\googlecode\\sparkleg\\Sparql.g:164:19: ( offsetClause )?
 4375  38
                     int alt32=2;
 4376  38
                     switch ( input.LA(1) ) {
 4377  
                         case OFFSET:
 4378  
                             {
 4379  12
                             alt32=1;
 4380  
                             }
 4381  
                             break;
 4382  
                     }
 4383  
 
 4384  38
                     switch (alt32) {
 4385  
                         case 1 :
 4386  
                             // com\\googlecode\\sparkleg\\Sparql.g:164:19: offsetClause
 4387  
                             {
 4388  12
                             pushFollow(FOLLOW_offsetClause_in_limitOffsetClauses1119);
 4389  12
                             offsetClause89=offsetClause();
 4390  
 
 4391  12
                             state._fsp--;
 4392  
 
 4393  12
                             stream_offsetClause.add(offsetClause89.getTree());
 4394  
 
 4395  
                             }
 4396  
                             break;
 4397  
 
 4398  
                     }
 4399  
 
 4400  
 
 4401  
                     // AST REWRITE
 4402  
                     // elements: limitClause, offsetClause
 4403  
                     // token labels: 
 4404  
                     // rule labels: retval
 4405  
                     // token list labels: 
 4406  
                     // rule list labels: 
 4407  
                     // wildcard labels: 
 4408  38
                     retval.tree = root_0;
 4409  38
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4410  
 
 4411  38
                     root_0 = (Object)adaptor.nil();
 4412  
                     // 164:33: -> limitClause ( offsetClause )*
 4413  
                     {
 4414  38
                         adaptor.addChild(root_0, stream_limitClause.nextTree());
 4415  
 
 4416  
                         // com\\googlecode\\sparkleg\\Sparql.g:164:48: ( offsetClause )*
 4417  50
                         while ( stream_offsetClause.hasNext() ) {
 4418  12
                             adaptor.addChild(root_0, stream_offsetClause.nextTree());
 4419  
 
 4420  
                         }
 4421  38
                         stream_offsetClause.reset();
 4422  
 
 4423  
                     }
 4424  
 
 4425  
 
 4426  38
                     retval.tree = root_0;
 4427  
 
 4428  
                     }
 4429  38
                     break;
 4430  
                 case 2 :
 4431  
                     // com\\googlecode\\sparkleg\\Sparql.g:165:7: offsetClause ( limitClause )?
 4432  
                     {
 4433  20
                     pushFollow(FOLLOW_offsetClause_in_limitOffsetClauses1135);
 4434  20
                     offsetClause90=offsetClause();
 4435  
 
 4436  20
                     state._fsp--;
 4437  
 
 4438  20
                     stream_offsetClause.add(offsetClause90.getTree());
 4439  
 
 4440  
                     // com\\googlecode\\sparkleg\\Sparql.g:165:20: ( limitClause )?
 4441  20
                     int alt33=2;
 4442  20
                     switch ( input.LA(1) ) {
 4443  
                         case LIMIT:
 4444  
                             {
 4445  10
                             alt33=1;
 4446  
                             }
 4447  
                             break;
 4448  
                     }
 4449  
 
 4450  20
                     switch (alt33) {
 4451  
                         case 1 :
 4452  
                             // com\\googlecode\\sparkleg\\Sparql.g:165:20: limitClause
 4453  
                             {
 4454  10
                             pushFollow(FOLLOW_limitClause_in_limitOffsetClauses1137);
 4455  10
                             limitClause91=limitClause();
 4456  
 
 4457  10
                             state._fsp--;
 4458  
 
 4459  10
                             stream_limitClause.add(limitClause91.getTree());
 4460  
 
 4461  
                             }
 4462  
                             break;
 4463  
 
 4464  
                     }
 4465  
 
 4466  
 
 4467  
                     // AST REWRITE
 4468  
                     // elements: limitClause, offsetClause
 4469  
                     // token labels: 
 4470  
                     // rule labels: retval
 4471  
                     // token list labels: 
 4472  
                     // rule list labels: 
 4473  
                     // wildcard labels: 
 4474  20
                     retval.tree = root_0;
 4475  20
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4476  
 
 4477  20
                     root_0 = (Object)adaptor.nil();
 4478  
                     // 165:33: -> offsetClause ( limitClause )*
 4479  
                     {
 4480  20
                         adaptor.addChild(root_0, stream_offsetClause.nextTree());
 4481  
 
 4482  
                         // com\\googlecode\\sparkleg\\Sparql.g:165:49: ( limitClause )*
 4483  30
                         while ( stream_limitClause.hasNext() ) {
 4484  10
                             adaptor.addChild(root_0, stream_limitClause.nextTree());
 4485  
 
 4486  
                         }
 4487  20
                         stream_limitClause.reset();
 4488  
 
 4489  
                     }
 4490  
 
 4491  
 
 4492  20
                     retval.tree = root_0;
 4493  
 
 4494  
                     }
 4495  
                     break;
 4496  
 
 4497  
             }
 4498  58
             retval.stop = input.LT(-1);
 4499  
 
 4500  
 
 4501  58
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4502  58
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4503  
 
 4504  
         }
 4505  0
         catch (RecognitionException re) {
 4506  0
             reportError(re);
 4507  0
             recover(input,re);
 4508  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4509  
 
 4510  
         }
 4511  
 
 4512  0
         finally {
 4513  
                 // do for sure before leaving
 4514  58
         }
 4515  58
         return retval;
 4516  
     }
 4517  
     // $ANTLR end "limitOffsetClauses"
 4518  
 
 4519  
 
 4520  48
     public static class limitClause_return extends ParserRuleReturnScope {
 4521  
         Object tree;
 4522  48
         public Object getTree() { return tree; }
 4523  
     };
 4524  
 
 4525  
 
 4526  
     // $ANTLR start "limitClause"
 4527  
     // com\\googlecode\\sparkleg\\Sparql.g:168:1: limitClause : LIMIT INTEGER -> ^( LIMIT INTEGER ) ;
 4528  
     public final SparqlParser.limitClause_return limitClause() throws RecognitionException {
 4529  48
         SparqlParser.limitClause_return retval = new SparqlParser.limitClause_return();
 4530  48
         retval.start = input.LT(1);
 4531  
 
 4532  
 
 4533  48
         Object root_0 = null;
 4534  
 
 4535  48
         Token LIMIT92=null;
 4536  48
         Token INTEGER93=null;
 4537  
 
 4538  48
         Object LIMIT92_tree=null;
 4539  48
         Object INTEGER93_tree=null;
 4540  48
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 4541  48
         RewriteRuleTokenStream stream_LIMIT=new RewriteRuleTokenStream(adaptor,"token LIMIT");
 4542  
 
 4543  
         try {
 4544  
             // com\\googlecode\\sparkleg\\Sparql.g:169:5: ( LIMIT INTEGER -> ^( LIMIT INTEGER ) )
 4545  
             // com\\googlecode\\sparkleg\\Sparql.g:169:7: LIMIT INTEGER
 4546  
             {
 4547  48
             LIMIT92=(Token)match(input,LIMIT,FOLLOW_LIMIT_in_limitClause1162);  
 4548  48
             stream_LIMIT.add(LIMIT92);
 4549  
 
 4550  
 
 4551  48
             INTEGER93=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_limitClause1164);  
 4552  48
             stream_INTEGER.add(INTEGER93);
 4553  
 
 4554  
 
 4555  
             // AST REWRITE
 4556  
             // elements: LIMIT, INTEGER
 4557  
             // token labels: 
 4558  
             // rule labels: retval
 4559  
             // token list labels: 
 4560  
             // rule list labels: 
 4561  
             // wildcard labels: 
 4562  48
             retval.tree = root_0;
 4563  48
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4564  
 
 4565  48
             root_0 = (Object)adaptor.nil();
 4566  
             // 169:21: -> ^( LIMIT INTEGER )
 4567  
             {
 4568  
                 // com\\googlecode\\sparkleg\\Sparql.g:169:24: ^( LIMIT INTEGER )
 4569  
                 {
 4570  48
                 Object root_1 = (Object)adaptor.nil();
 4571  48
                 root_1 = (Object)adaptor.becomeRoot(
 4572  
                 stream_LIMIT.nextNode()
 4573  
                 , root_1);
 4574  
 
 4575  48
                 adaptor.addChild(root_1, 
 4576  
                 stream_INTEGER.nextNode()
 4577  
                 );
 4578  
 
 4579  48
                 adaptor.addChild(root_0, root_1);
 4580  
                 }
 4581  
 
 4582  
             }
 4583  
 
 4584  
 
 4585  48
             retval.tree = root_0;
 4586  
 
 4587  
             }
 4588  
 
 4589  48
             retval.stop = input.LT(-1);
 4590  
 
 4591  
 
 4592  48
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4593  48
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4594  
 
 4595  
         }
 4596  0
         catch (RecognitionException re) {
 4597  0
             reportError(re);
 4598  0
             recover(input,re);
 4599  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4600  
 
 4601  
         }
 4602  
 
 4603  0
         finally {
 4604  
                 // do for sure before leaving
 4605  48
         }
 4606  48
         return retval;
 4607  
     }
 4608  
     // $ANTLR end "limitClause"
 4609  
 
 4610  
 
 4611  32
     public static class offsetClause_return extends ParserRuleReturnScope {
 4612  
         Object tree;
 4613  32
         public Object getTree() { return tree; }
 4614  
     };
 4615  
 
 4616  
 
 4617  
     // $ANTLR start "offsetClause"
 4618  
     // com\\googlecode\\sparkleg\\Sparql.g:172:1: offsetClause : OFFSET INTEGER -> ^( OFFSET INTEGER ) ;
 4619  
     public final SparqlParser.offsetClause_return offsetClause() throws RecognitionException {
 4620  32
         SparqlParser.offsetClause_return retval = new SparqlParser.offsetClause_return();
 4621  32
         retval.start = input.LT(1);
 4622  
 
 4623  
 
 4624  32
         Object root_0 = null;
 4625  
 
 4626  32
         Token OFFSET94=null;
 4627  32
         Token INTEGER95=null;
 4628  
 
 4629  32
         Object OFFSET94_tree=null;
 4630  32
         Object INTEGER95_tree=null;
 4631  32
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 4632  32
         RewriteRuleTokenStream stream_OFFSET=new RewriteRuleTokenStream(adaptor,"token OFFSET");
 4633  
 
 4634  
         try {
 4635  
             // com\\googlecode\\sparkleg\\Sparql.g:173:5: ( OFFSET INTEGER -> ^( OFFSET INTEGER ) )
 4636  
             // com\\googlecode\\sparkleg\\Sparql.g:173:7: OFFSET INTEGER
 4637  
             {
 4638  32
             OFFSET94=(Token)match(input,OFFSET,FOLLOW_OFFSET_in_offsetClause1189);  
 4639  32
             stream_OFFSET.add(OFFSET94);
 4640  
 
 4641  
 
 4642  32
             INTEGER95=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_offsetClause1191);  
 4643  32
             stream_INTEGER.add(INTEGER95);
 4644  
 
 4645  
 
 4646  
             // AST REWRITE
 4647  
             // elements: INTEGER, OFFSET
 4648  
             // token labels: 
 4649  
             // rule labels: retval
 4650  
             // token list labels: 
 4651  
             // rule list labels: 
 4652  
             // wildcard labels: 
 4653  32
             retval.tree = root_0;
 4654  32
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4655  
 
 4656  32
             root_0 = (Object)adaptor.nil();
 4657  
             // 173:22: -> ^( OFFSET INTEGER )
 4658  
             {
 4659  
                 // com\\googlecode\\sparkleg\\Sparql.g:173:25: ^( OFFSET INTEGER )
 4660  
                 {
 4661  32
                 Object root_1 = (Object)adaptor.nil();
 4662  32
                 root_1 = (Object)adaptor.becomeRoot(
 4663  
                 stream_OFFSET.nextNode()
 4664  
                 , root_1);
 4665  
 
 4666  32
                 adaptor.addChild(root_1, 
 4667  
                 stream_INTEGER.nextNode()
 4668  
                 );
 4669  
 
 4670  32
                 adaptor.addChild(root_0, root_1);
 4671  
                 }
 4672  
 
 4673  
             }
 4674  
 
 4675  
 
 4676  32
             retval.tree = root_0;
 4677  
 
 4678  
             }
 4679  
 
 4680  32
             retval.stop = input.LT(-1);
 4681  
 
 4682  
 
 4683  32
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4684  32
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4685  
 
 4686  
         }
 4687  0
         catch (RecognitionException re) {
 4688  0
             reportError(re);
 4689  0
             recover(input,re);
 4690  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4691  
 
 4692  
         }
 4693  
 
 4694  0
         finally {
 4695  
                 // do for sure before leaving
 4696  32
         }
 4697  32
         return retval;
 4698  
     }
 4699  
     // $ANTLR end "offsetClause"
 4700  
 
 4701  
 
 4702  1834
     public static class bindingsClause_return extends ParserRuleReturnScope {
 4703  
         Object tree;
 4704  1834
         public Object getTree() { return tree; }
 4705  
     };
 4706  
 
 4707  
 
 4708  
     // $ANTLR start "bindingsClause"
 4709  
     // com\\googlecode\\sparkleg\\Sparql.g:176:1: bindingsClause : ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )? -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )? ;
 4710  
     public final SparqlParser.bindingsClause_return bindingsClause() throws RecognitionException {
 4711  1834
         SparqlParser.bindingsClause_return retval = new SparqlParser.bindingsClause_return();
 4712  1834
         retval.start = input.LT(1);
 4713  
 
 4714  
 
 4715  1834
         Object root_0 = null;
 4716  
 
 4717  1834
         Token BINDINGS96=null;
 4718  1834
         Token OPEN_CURLY_BRACE98=null;
 4719  1834
         Token CLOSE_CURLY_BRACE100=null;
 4720  1834
         SparqlParser.var_return var97 =null;
 4721  
 
 4722  1834
         SparqlParser.bindingValueList_return bindingValueList99 =null;
 4723  
 
 4724  
 
 4725  1834
         Object BINDINGS96_tree=null;
 4726  1834
         Object OPEN_CURLY_BRACE98_tree=null;
 4727  1834
         Object CLOSE_CURLY_BRACE100_tree=null;
 4728  1834
         RewriteRuleTokenStream stream_BINDINGS=new RewriteRuleTokenStream(adaptor,"token BINDINGS");
 4729  1834
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 4730  1834
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 4731  1834
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 4732  1834
         RewriteRuleSubtreeStream stream_bindingValueList=new RewriteRuleSubtreeStream(adaptor,"rule bindingValueList");
 4733  
         try {
 4734  
             // com\\googlecode\\sparkleg\\Sparql.g:177:5: ( ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )? -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )? )
 4735  
             // com\\googlecode\\sparkleg\\Sparql.g:177:7: ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )?
 4736  
             {
 4737  
             // com\\googlecode\\sparkleg\\Sparql.g:177:7: ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )?
 4738  1834
             int alt37=2;
 4739  1834
             switch ( input.LA(1) ) {
 4740  
                 case BINDINGS:
 4741  
                     {
 4742  26
                     alt37=1;
 4743  
                     }
 4744  
                     break;
 4745  
             }
 4746  
 
 4747  1834
             switch (alt37) {
 4748  
                 case 1 :
 4749  
                     // com\\googlecode\\sparkleg\\Sparql.g:177:8: BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE
 4750  
                     {
 4751  26
                     BINDINGS96=(Token)match(input,BINDINGS,FOLLOW_BINDINGS_in_bindingsClause1217);  
 4752  26
                     stream_BINDINGS.add(BINDINGS96);
 4753  
 
 4754  
 
 4755  
                     // com\\googlecode\\sparkleg\\Sparql.g:177:17: ( var )*
 4756  
                     loop35:
 4757  
                     do {
 4758  64
                         int alt35=2;
 4759  64
                         switch ( input.LA(1) ) {
 4760  
                         case VAR1:
 4761  
                         case VAR2:
 4762  
                             {
 4763  38
                             alt35=1;
 4764  
                             }
 4765  
                             break;
 4766  
 
 4767  
                         }
 4768  
 
 4769  64
                         switch (alt35) {
 4770  
                             case 1 :
 4771  
                                 // com\\googlecode\\sparkleg\\Sparql.g:177:17: var
 4772  
                                 {
 4773  38
                                 pushFollow(FOLLOW_var_in_bindingsClause1219);
 4774  38
                                 var97=var();
 4775  
 
 4776  38
                                 state._fsp--;
 4777  
 
 4778  38
                                 stream_var.add(var97.getTree());
 4779  
 
 4780  
                                 }
 4781  38
                                 break;
 4782  
 
 4783  
                             default :
 4784  26
                                 break loop35;
 4785  
                         }
 4786  38
                     } while (true);
 4787  
 
 4788  
 
 4789  26
                     OPEN_CURLY_BRACE98=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_bindingsClause1222);  
 4790  26
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE98);
 4791  
 
 4792  
 
 4793  
                     // com\\googlecode\\sparkleg\\Sparql.g:177:39: ( bindingValueList )*
 4794  
                     loop36:
 4795  
                     do {
 4796  60
                         int alt36=2;
 4797  60
                         switch ( input.LA(1) ) {
 4798  
                         case OPEN_BRACE:
 4799  
                             {
 4800  34
                             alt36=1;
 4801  
                             }
 4802  
                             break;
 4803  
 
 4804  
                         }
 4805  
 
 4806  60
                         switch (alt36) {
 4807  
                             case 1 :
 4808  
                                 // com\\googlecode\\sparkleg\\Sparql.g:177:39: bindingValueList
 4809  
                                 {
 4810  34
                                 pushFollow(FOLLOW_bindingValueList_in_bindingsClause1224);
 4811  34
                                 bindingValueList99=bindingValueList();
 4812  
 
 4813  34
                                 state._fsp--;
 4814  
 
 4815  34
                                 stream_bindingValueList.add(bindingValueList99.getTree());
 4816  
 
 4817  
                                 }
 4818  34
                                 break;
 4819  
 
 4820  
                             default :
 4821  26
                                 break loop36;
 4822  
                         }
 4823  34
                     } while (true);
 4824  
 
 4825  
 
 4826  26
                     CLOSE_CURLY_BRACE100=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_bindingsClause1227);  
 4827  26
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE100);
 4828  
 
 4829  
 
 4830  
                     }
 4831  
                     break;
 4832  
 
 4833  
             }
 4834  
 
 4835  
 
 4836  
             // AST REWRITE
 4837  
             // elements: var, bindingValueList, BINDINGS
 4838  
             // token labels: 
 4839  
             // rule labels: retval
 4840  
             // token list labels: 
 4841  
             // rule list labels: 
 4842  
             // wildcard labels: 
 4843  1834
             retval.tree = root_0;
 4844  1834
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4845  
 
 4846  1834
             root_0 = (Object)adaptor.nil();
 4847  
             // 177:77: -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )?
 4848  
             {
 4849  
                 // com\\googlecode\\sparkleg\\Sparql.g:177:80: ( ^( BINDINGS ( var )* ( bindingValueList )* ) )?
 4850  1834
                 if ( stream_var.hasNext()||stream_bindingValueList.hasNext()||stream_BINDINGS.hasNext() ) {
 4851  
                     // com\\googlecode\\sparkleg\\Sparql.g:177:80: ^( BINDINGS ( var )* ( bindingValueList )* )
 4852  
                     {
 4853  26
                     Object root_1 = (Object)adaptor.nil();
 4854  26
                     root_1 = (Object)adaptor.becomeRoot(
 4855  
                     stream_BINDINGS.nextNode()
 4856  
                     , root_1);
 4857  
 
 4858  
                     // com\\googlecode\\sparkleg\\Sparql.g:177:91: ( var )*
 4859  64
                     while ( stream_var.hasNext() ) {
 4860  38
                         adaptor.addChild(root_1, stream_var.nextTree());
 4861  
 
 4862  
                     }
 4863  26
                     stream_var.reset();
 4864  
 
 4865  
                     // com\\googlecode\\sparkleg\\Sparql.g:177:96: ( bindingValueList )*
 4866  60
                     while ( stream_bindingValueList.hasNext() ) {
 4867  34
                         adaptor.addChild(root_1, stream_bindingValueList.nextTree());
 4868  
 
 4869  
                     }
 4870  26
                     stream_bindingValueList.reset();
 4871  
 
 4872  26
                     adaptor.addChild(root_0, root_1);
 4873  
                     }
 4874  
 
 4875  
                 }
 4876  1834
                 stream_var.reset();
 4877  1834
                 stream_bindingValueList.reset();
 4878  1834
                 stream_BINDINGS.reset();
 4879  
 
 4880  
             }
 4881  
 
 4882  
 
 4883  1834
             retval.tree = root_0;
 4884  
 
 4885  
             }
 4886  
 
 4887  1834
             retval.stop = input.LT(-1);
 4888  
 
 4889  
 
 4890  1834
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4891  1834
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4892  
 
 4893  
         }
 4894  0
         catch (RecognitionException re) {
 4895  0
             reportError(re);
 4896  0
             recover(input,re);
 4897  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4898  
 
 4899  
         }
 4900  
 
 4901  0
         finally {
 4902  
                 // do for sure before leaving
 4903  1834
         }
 4904  1834
         return retval;
 4905  
     }
 4906  
     // $ANTLR end "bindingsClause"
 4907  
 
 4908  
 
 4909  34
     public static class bindingValueList_return extends ParserRuleReturnScope {
 4910  
         Object tree;
 4911  34
         public Object getTree() { return tree; }
 4912  
     };
 4913  
 
 4914  
 
 4915  
     // $ANTLR start "bindingValueList"
 4916  
     // com\\googlecode\\sparkleg\\Sparql.g:180:1: bindingValueList : OPEN_BRACE ( bindingValue )* CLOSE_BRACE -> ^( BINDING_VALUE ( bindingValue )* ) ;
 4917  
     public final SparqlParser.bindingValueList_return bindingValueList() throws RecognitionException {
 4918  34
         SparqlParser.bindingValueList_return retval = new SparqlParser.bindingValueList_return();
 4919  34
         retval.start = input.LT(1);
 4920  
 
 4921  
 
 4922  34
         Object root_0 = null;
 4923  
 
 4924  34
         Token OPEN_BRACE101=null;
 4925  34
         Token CLOSE_BRACE103=null;
 4926  34
         SparqlParser.bindingValue_return bindingValue102 =null;
 4927  
 
 4928  
 
 4929  34
         Object OPEN_BRACE101_tree=null;
 4930  34
         Object CLOSE_BRACE103_tree=null;
 4931  34
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 4932  34
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 4933  34
         RewriteRuleSubtreeStream stream_bindingValue=new RewriteRuleSubtreeStream(adaptor,"rule bindingValue");
 4934  
         try {
 4935  
             // com\\googlecode\\sparkleg\\Sparql.g:181:5: ( OPEN_BRACE ( bindingValue )* CLOSE_BRACE -> ^( BINDING_VALUE ( bindingValue )* ) )
 4936  
             // com\\googlecode\\sparkleg\\Sparql.g:181:7: OPEN_BRACE ( bindingValue )* CLOSE_BRACE
 4937  
             {
 4938  34
             OPEN_BRACE101=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_bindingValueList1263);  
 4939  34
             stream_OPEN_BRACE.add(OPEN_BRACE101);
 4940  
 
 4941  
 
 4942  
             // com\\googlecode\\sparkleg\\Sparql.g:181:18: ( bindingValue )*
 4943  
             loop38:
 4944  
             do {
 4945  88
                 int alt38=2;
 4946  88
                 switch ( input.LA(1) ) {
 4947  
                 case DECIMAL:
 4948  
                 case DECIMAL_NEGATIVE:
 4949  
                 case DECIMAL_POSITIVE:
 4950  
                 case DOUBLE:
 4951  
                 case DOUBLE_NEGATIVE:
 4952  
                 case DOUBLE_POSITIVE:
 4953  
                 case FALSE:
 4954  
                 case INTEGER:
 4955  
                 case INTEGER_NEGATIVE:
 4956  
                 case INTEGER_POSITIVE:
 4957  
                 case IRI_REF:
 4958  
                 case PNAME_LN:
 4959  
                 case PNAME_NS:
 4960  
                 case STRING_LITERAL1:
 4961  
                 case STRING_LITERAL2:
 4962  
                 case STRING_LITERAL_LONG1:
 4963  
                 case STRING_LITERAL_LONG2:
 4964  
                 case TRUE:
 4965  
                 case UNDEF:
 4966  
                     {
 4967  54
                     alt38=1;
 4968  
                     }
 4969  
                     break;
 4970  
 
 4971  
                 }
 4972  
 
 4973  88
                 switch (alt38) {
 4974  
                     case 1 :
 4975  
                         // com\\googlecode\\sparkleg\\Sparql.g:181:18: bindingValue
 4976  
                         {
 4977  54
                         pushFollow(FOLLOW_bindingValue_in_bindingValueList1265);
 4978  54
                         bindingValue102=bindingValue();
 4979  
 
 4980  54
                         state._fsp--;
 4981  
 
 4982  54
                         stream_bindingValue.add(bindingValue102.getTree());
 4983  
 
 4984  
                         }
 4985  54
                         break;
 4986  
 
 4987  
                     default :
 4988  34
                         break loop38;
 4989  
                 }
 4990  54
             } while (true);
 4991  
 
 4992  
 
 4993  34
             CLOSE_BRACE103=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_bindingValueList1268);  
 4994  34
             stream_CLOSE_BRACE.add(CLOSE_BRACE103);
 4995  
 
 4996  
 
 4997  
             // AST REWRITE
 4998  
             // elements: bindingValue
 4999  
             // token labels: 
 5000  
             // rule labels: retval
 5001  
             // token list labels: 
 5002  
             // rule list labels: 
 5003  
             // wildcard labels: 
 5004  34
             retval.tree = root_0;
 5005  34
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5006  
 
 5007  34
             root_0 = (Object)adaptor.nil();
 5008  
             // 181:44: -> ^( BINDING_VALUE ( bindingValue )* )
 5009  
             {
 5010  
                 // com\\googlecode\\sparkleg\\Sparql.g:181:47: ^( BINDING_VALUE ( bindingValue )* )
 5011  
                 {
 5012  34
                 Object root_1 = (Object)adaptor.nil();
 5013  34
                 root_1 = (Object)adaptor.becomeRoot(
 5014  
                 (Object)adaptor.create(BINDING_VALUE, "BINDING_VALUE")
 5015  
                 , root_1);
 5016  
 
 5017  
                 // com\\googlecode\\sparkleg\\Sparql.g:181:63: ( bindingValue )*
 5018  88
                 while ( stream_bindingValue.hasNext() ) {
 5019  54
                     adaptor.addChild(root_1, stream_bindingValue.nextTree());
 5020  
 
 5021  
                 }
 5022  34
                 stream_bindingValue.reset();
 5023  
 
 5024  34
                 adaptor.addChild(root_0, root_1);
 5025  
                 }
 5026  
 
 5027  
             }
 5028  
 
 5029  
 
 5030  34
             retval.tree = root_0;
 5031  
 
 5032  
             }
 5033  
 
 5034  34
             retval.stop = input.LT(-1);
 5035  
 
 5036  
 
 5037  34
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5038  34
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5039  
 
 5040  
         }
 5041  0
         catch (RecognitionException re) {
 5042  0
             reportError(re);
 5043  0
             recover(input,re);
 5044  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5045  
 
 5046  
         }
 5047  
 
 5048  0
         finally {
 5049  
                 // do for sure before leaving
 5050  34
         }
 5051  34
         return retval;
 5052  
     }
 5053  
     // $ANTLR end "bindingValueList"
 5054  
 
 5055  
 
 5056  54
     public static class bindingValue_return extends ParserRuleReturnScope {
 5057  
         Object tree;
 5058  54
         public Object getTree() { return tree; }
 5059  
     };
 5060  
 
 5061  
 
 5062  
     // $ANTLR start "bindingValue"
 5063  
     // com\\googlecode\\sparkleg\\Sparql.g:184:1: bindingValue : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF );
 5064  
     public final SparqlParser.bindingValue_return bindingValue() throws RecognitionException {
 5065  54
         SparqlParser.bindingValue_return retval = new SparqlParser.bindingValue_return();
 5066  54
         retval.start = input.LT(1);
 5067  
 
 5068  
 
 5069  54
         Object root_0 = null;
 5070  
 
 5071  54
         Token UNDEF108=null;
 5072  54
         SparqlParser.iriRef_return iriRef104 =null;
 5073  
 
 5074  54
         SparqlParser.rdfLiteral_return rdfLiteral105 =null;
 5075  
 
 5076  54
         SparqlParser.numericLiteral_return numericLiteral106 =null;
 5077  
 
 5078  54
         SparqlParser.booleanLiteral_return booleanLiteral107 =null;
 5079  
 
 5080  
 
 5081  54
         Object UNDEF108_tree=null;
 5082  
 
 5083  
         try {
 5084  
             // com\\googlecode\\sparkleg\\Sparql.g:185:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF )
 5085  54
             int alt39=5;
 5086  54
             switch ( input.LA(1) ) {
 5087  
             case IRI_REF:
 5088  
             case PNAME_LN:
 5089  
             case PNAME_NS:
 5090  
                 {
 5091  22
                 alt39=1;
 5092  
                 }
 5093  22
                 break;
 5094  
             case STRING_LITERAL1:
 5095  
             case STRING_LITERAL2:
 5096  
             case STRING_LITERAL_LONG1:
 5097  
             case STRING_LITERAL_LONG2:
 5098  
                 {
 5099  14
                 alt39=2;
 5100  
                 }
 5101  14
                 break;
 5102  
             case DECIMAL:
 5103  
             case DECIMAL_NEGATIVE:
 5104  
             case DECIMAL_POSITIVE:
 5105  
             case DOUBLE:
 5106  
             case DOUBLE_NEGATIVE:
 5107  
             case DOUBLE_POSITIVE:
 5108  
             case INTEGER:
 5109  
             case INTEGER_NEGATIVE:
 5110  
             case INTEGER_POSITIVE:
 5111  
                 {
 5112  0
                 alt39=3;
 5113  
                 }
 5114  0
                 break;
 5115  
             case FALSE:
 5116  
             case TRUE:
 5117  
                 {
 5118  0
                 alt39=4;
 5119  
                 }
 5120  0
                 break;
 5121  
             case UNDEF:
 5122  
                 {
 5123  18
                 alt39=5;
 5124  
                 }
 5125  18
                 break;
 5126  
             default:
 5127  0
                 NoViableAltException nvae =
 5128  
                     new NoViableAltException("", 39, 0, input);
 5129  
 
 5130  0
                 throw nvae;
 5131  
 
 5132  
             }
 5133  
 
 5134  54
             switch (alt39) {
 5135  
                 case 1 :
 5136  
                     // com\\googlecode\\sparkleg\\Sparql.g:185:7: iriRef
 5137  
                     {
 5138  22
                     root_0 = (Object)adaptor.nil();
 5139  
 
 5140  
 
 5141  22
                     pushFollow(FOLLOW_iriRef_in_bindingValue1299);
 5142  22
                     iriRef104=iriRef();
 5143  
 
 5144  22
                     state._fsp--;
 5145  
 
 5146  22
                     adaptor.addChild(root_0, iriRef104.getTree());
 5147  
 
 5148  
                     }
 5149  22
                     break;
 5150  
                 case 2 :
 5151  
                     // com\\googlecode\\sparkleg\\Sparql.g:185:16: rdfLiteral
 5152  
                     {
 5153  14
                     root_0 = (Object)adaptor.nil();
 5154  
 
 5155  
 
 5156  14
                     pushFollow(FOLLOW_rdfLiteral_in_bindingValue1303);
 5157  14
                     rdfLiteral105=rdfLiteral();
 5158  
 
 5159  14
                     state._fsp--;
 5160  
 
 5161  14
                     adaptor.addChild(root_0, rdfLiteral105.getTree());
 5162  
 
 5163  
                     }
 5164  14
                     break;
 5165  
                 case 3 :
 5166  
                     // com\\googlecode\\sparkleg\\Sparql.g:185:29: numericLiteral
 5167  
                     {
 5168  0
                     root_0 = (Object)adaptor.nil();
 5169  
 
 5170  
 
 5171  0
                     pushFollow(FOLLOW_numericLiteral_in_bindingValue1307);
 5172  0
                     numericLiteral106=numericLiteral();
 5173  
 
 5174  0
                     state._fsp--;
 5175  
 
 5176  0
                     adaptor.addChild(root_0, numericLiteral106.getTree());
 5177  
 
 5178  
                     }
 5179  0
                     break;
 5180  
                 case 4 :
 5181  
                     // com\\googlecode\\sparkleg\\Sparql.g:185:46: booleanLiteral
 5182  
                     {
 5183  0
                     root_0 = (Object)adaptor.nil();
 5184  
 
 5185  
 
 5186  0
                     pushFollow(FOLLOW_booleanLiteral_in_bindingValue1311);
 5187  0
                     booleanLiteral107=booleanLiteral();
 5188  
 
 5189  0
                     state._fsp--;
 5190  
 
 5191  0
                     adaptor.addChild(root_0, booleanLiteral107.getTree());
 5192  
 
 5193  
                     }
 5194  0
                     break;
 5195  
                 case 5 :
 5196  
                     // com\\googlecode\\sparkleg\\Sparql.g:185:63: UNDEF
 5197  
                     {
 5198  18
                     root_0 = (Object)adaptor.nil();
 5199  
 
 5200  
 
 5201  18
                     UNDEF108=(Token)match(input,UNDEF,FOLLOW_UNDEF_in_bindingValue1315); 
 5202  18
                     UNDEF108_tree = 
 5203  
                     (Object)adaptor.create(UNDEF108)
 5204  
                     ;
 5205  18
                     adaptor.addChild(root_0, UNDEF108_tree);
 5206  
 
 5207  
 
 5208  
                     }
 5209  
                     break;
 5210  
 
 5211  
             }
 5212  54
             retval.stop = input.LT(-1);
 5213  
 
 5214  
 
 5215  54
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5216  54
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5217  
 
 5218  
         }
 5219  0
         catch (RecognitionException re) {
 5220  0
             reportError(re);
 5221  0
             recover(input,re);
 5222  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5223  
 
 5224  
         }
 5225  
 
 5226  0
         finally {
 5227  
                 // do for sure before leaving
 5228  54
         }
 5229  54
         return retval;
 5230  
     }
 5231  
     // $ANTLR end "bindingValue"
 5232  
 
 5233  
 
 5234  128
     public static class update_return extends ParserRuleReturnScope {
 5235  
         Object tree;
 5236  128
         public Object getTree() { return tree; }
 5237  
     };
 5238  
 
 5239  
 
 5240  
     // $ANTLR start "update"
 5241  
     // com\\googlecode\\sparkleg\\Sparql.g:188:1: update : prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify ) -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* ;
 5242  
     public final SparqlParser.update_return update() throws RecognitionException {
 5243  128
         SparqlParser.update_return retval = new SparqlParser.update_return();
 5244  128
         retval.start = input.LT(1);
 5245  
 
 5246  
 
 5247  128
         Object root_0 = null;
 5248  
 
 5249  128
         SparqlParser.prologue_return prologue109 =null;
 5250  
 
 5251  128
         SparqlParser.load_return load110 =null;
 5252  
 
 5253  128
         SparqlParser.clear_return clear111 =null;
 5254  
 
 5255  128
         SparqlParser.drop_return drop112 =null;
 5256  
 
 5257  128
         SparqlParser.add_return add113 =null;
 5258  
 
 5259  128
         SparqlParser.move_return move114 =null;
 5260  
 
 5261  128
         SparqlParser.copy_return copy115 =null;
 5262  
 
 5263  128
         SparqlParser.create_return create116 =null;
 5264  
 
 5265  128
         SparqlParser.insert_return insert117 =null;
 5266  
 
 5267  128
         SparqlParser.delete_return delete118 =null;
 5268  
 
 5269  128
         SparqlParser.modify_return modify119 =null;
 5270  
 
 5271  
 
 5272  128
         RewriteRuleSubtreeStream stream_clear=new RewriteRuleSubtreeStream(adaptor,"rule clear");
 5273  128
         RewriteRuleSubtreeStream stream_prologue=new RewriteRuleSubtreeStream(adaptor,"rule prologue");
 5274  128
         RewriteRuleSubtreeStream stream_drop=new RewriteRuleSubtreeStream(adaptor,"rule drop");
 5275  128
         RewriteRuleSubtreeStream stream_delete=new RewriteRuleSubtreeStream(adaptor,"rule delete");
 5276  128
         RewriteRuleSubtreeStream stream_modify=new RewriteRuleSubtreeStream(adaptor,"rule modify");
 5277  128
         RewriteRuleSubtreeStream stream_load=new RewriteRuleSubtreeStream(adaptor,"rule load");
 5278  128
         RewriteRuleSubtreeStream stream_add=new RewriteRuleSubtreeStream(adaptor,"rule add");
 5279  128
         RewriteRuleSubtreeStream stream_insert=new RewriteRuleSubtreeStream(adaptor,"rule insert");
 5280  128
         RewriteRuleSubtreeStream stream_create=new RewriteRuleSubtreeStream(adaptor,"rule create");
 5281  128
         RewriteRuleSubtreeStream stream_move=new RewriteRuleSubtreeStream(adaptor,"rule move");
 5282  128
         RewriteRuleSubtreeStream stream_copy=new RewriteRuleSubtreeStream(adaptor,"rule copy");
 5283  
         try {
 5284  
             // com\\googlecode\\sparkleg\\Sparql.g:189:5: ( prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify ) -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* )
 5285  
             // com\\googlecode\\sparkleg\\Sparql.g:189:7: prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify )
 5286  
             {
 5287  128
             pushFollow(FOLLOW_prologue_in_update1336);
 5288  128
             prologue109=prologue();
 5289  
 
 5290  128
             state._fsp--;
 5291  
 
 5292  128
             stream_prologue.add(prologue109.getTree());
 5293  
 
 5294  
             // com\\googlecode\\sparkleg\\Sparql.g:189:16: ( load | clear | drop | add | move | copy | create | insert | delete | modify )
 5295  128
             int alt40=10;
 5296  128
             switch ( input.LA(1) ) {
 5297  
             case LOAD:
 5298  
                 {
 5299  0
                 alt40=1;
 5300  
                 }
 5301  0
                 break;
 5302  
             case CLEAR:
 5303  
                 {
 5304  8
                 alt40=2;
 5305  
                 }
 5306  8
                 break;
 5307  
             case DROP:
 5308  
                 {
 5309  8
                 alt40=3;
 5310  
                 }
 5311  8
                 break;
 5312  
             case ADD:
 5313  
                 {
 5314  0
                 alt40=4;
 5315  
                 }
 5316  0
                 break;
 5317  
             case MOVE:
 5318  
                 {
 5319  0
                 alt40=5;
 5320  
                 }
 5321  0
                 break;
 5322  
             case COPY:
 5323  
                 {
 5324  0
                 alt40=6;
 5325  
                 }
 5326  0
                 break;
 5327  
             case CREATE:
 5328  
                 {
 5329  0
                 alt40=7;
 5330  
                 }
 5331  0
                 break;
 5332  
             case INSERT:
 5333  
                 {
 5334  20
                 switch ( input.LA(2) ) {
 5335  
                 case DATA:
 5336  
                     {
 5337  8
                     alt40=8;
 5338  
                     }
 5339  8
                     break;
 5340  
                 case OPEN_CURLY_BRACE:
 5341  
                     {
 5342  12
                     alt40=10;
 5343  
                     }
 5344  12
                     break;
 5345  
                 default:
 5346  0
                     NoViableAltException nvae =
 5347  
                         new NoViableAltException("", 40, 8, input);
 5348  
 
 5349  0
                     throw nvae;
 5350  
 
 5351  
                 }
 5352  
 
 5353  
                 }
 5354  20
                 break;
 5355  
             case DELETE:
 5356  
                 {
 5357  78
                 switch ( input.LA(2) ) {
 5358  
                 case DATA:
 5359  
                 case WHERE:
 5360  
                     {
 5361  24
                     alt40=9;
 5362  
                     }
 5363  24
                     break;
 5364  
                 case OPEN_CURLY_BRACE:
 5365  
                     {
 5366  54
                     alt40=10;
 5367  
                     }
 5368  54
                     break;
 5369  
                 default:
 5370  0
                     NoViableAltException nvae =
 5371  
                         new NoViableAltException("", 40, 9, input);
 5372  
 
 5373  0
                     throw nvae;
 5374  
 
 5375  
                 }
 5376  
 
 5377  
                 }
 5378  78
                 break;
 5379  
             case WITH:
 5380  
                 {
 5381  14
                 alt40=10;
 5382  
                 }
 5383  14
                 break;
 5384  
             default:
 5385  0
                 NoViableAltException nvae =
 5386  
                     new NoViableAltException("", 40, 0, input);
 5387  
 
 5388  0
                 throw nvae;
 5389  
 
 5390  
             }
 5391  
 
 5392  128
             switch (alt40) {
 5393  
                 case 1 :
 5394  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:17: load
 5395  
                     {
 5396  0
                     pushFollow(FOLLOW_load_in_update1339);
 5397  0
                     load110=load();
 5398  
 
 5399  0
                     state._fsp--;
 5400  
 
 5401  0
                     stream_load.add(load110.getTree());
 5402  
 
 5403  
                     }
 5404  0
                     break;
 5405  
                 case 2 :
 5406  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:24: clear
 5407  
                     {
 5408  8
                     pushFollow(FOLLOW_clear_in_update1343);
 5409  8
                     clear111=clear();
 5410  
 
 5411  8
                     state._fsp--;
 5412  
 
 5413  8
                     stream_clear.add(clear111.getTree());
 5414  
 
 5415  
                     }
 5416  8
                     break;
 5417  
                 case 3 :
 5418  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:32: drop
 5419  
                     {
 5420  8
                     pushFollow(FOLLOW_drop_in_update1347);
 5421  8
                     drop112=drop();
 5422  
 
 5423  8
                     state._fsp--;
 5424  
 
 5425  8
                     stream_drop.add(drop112.getTree());
 5426  
 
 5427  
                     }
 5428  8
                     break;
 5429  
                 case 4 :
 5430  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:39: add
 5431  
                     {
 5432  0
                     pushFollow(FOLLOW_add_in_update1351);
 5433  0
                     add113=add();
 5434  
 
 5435  0
                     state._fsp--;
 5436  
 
 5437  0
                     stream_add.add(add113.getTree());
 5438  
 
 5439  
                     }
 5440  0
                     break;
 5441  
                 case 5 :
 5442  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:45: move
 5443  
                     {
 5444  0
                     pushFollow(FOLLOW_move_in_update1355);
 5445  0
                     move114=move();
 5446  
 
 5447  0
                     state._fsp--;
 5448  
 
 5449  0
                     stream_move.add(move114.getTree());
 5450  
 
 5451  
                     }
 5452  0
                     break;
 5453  
                 case 6 :
 5454  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:52: copy
 5455  
                     {
 5456  0
                     pushFollow(FOLLOW_copy_in_update1359);
 5457  0
                     copy115=copy();
 5458  
 
 5459  0
                     state._fsp--;
 5460  
 
 5461  0
                     stream_copy.add(copy115.getTree());
 5462  
 
 5463  
                     }
 5464  0
                     break;
 5465  
                 case 7 :
 5466  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:59: create
 5467  
                     {
 5468  0
                     pushFollow(FOLLOW_create_in_update1363);
 5469  0
                     create116=create();
 5470  
 
 5471  0
                     state._fsp--;
 5472  
 
 5473  0
                     stream_create.add(create116.getTree());
 5474  
 
 5475  
                     }
 5476  0
                     break;
 5477  
                 case 8 :
 5478  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:68: insert
 5479  
                     {
 5480  8
                     pushFollow(FOLLOW_insert_in_update1367);
 5481  8
                     insert117=insert();
 5482  
 
 5483  8
                     state._fsp--;
 5484  
 
 5485  8
                     stream_insert.add(insert117.getTree());
 5486  
 
 5487  
                     }
 5488  8
                     break;
 5489  
                 case 9 :
 5490  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:77: delete
 5491  
                     {
 5492  24
                     pushFollow(FOLLOW_delete_in_update1371);
 5493  24
                     delete118=delete();
 5494  
 
 5495  24
                     state._fsp--;
 5496  
 
 5497  24
                     stream_delete.add(delete118.getTree());
 5498  
 
 5499  
                     }
 5500  24
                     break;
 5501  
                 case 10 :
 5502  
                     // com\\googlecode\\sparkleg\\Sparql.g:189:86: modify
 5503  
                     {
 5504  80
                     pushFollow(FOLLOW_modify_in_update1375);
 5505  80
                     modify119=modify();
 5506  
 
 5507  80
                     state._fsp--;
 5508  
 
 5509  80
                     stream_modify.add(modify119.getTree());
 5510  
 
 5511  
                     }
 5512  
                     break;
 5513  
 
 5514  
             }
 5515  
 
 5516  
 
 5517  
             // AST REWRITE
 5518  
             // elements: create, modify, prologue, copy, insert, delete, clear, move, add, drop, load
 5519  
             // token labels: 
 5520  
             // rule labels: retval
 5521  
             // token list labels: 
 5522  
             // rule list labels: 
 5523  
             // wildcard labels: 
 5524  128
             retval.tree = root_0;
 5525  128
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5526  
 
 5527  128
             root_0 = (Object)adaptor.nil();
 5528  
             // 189:94: -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )*
 5529  
             {
 5530  128
                 adaptor.addChild(root_0, stream_prologue.nextTree());
 5531  
 
 5532  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:106: ( load )*
 5533  128
                 while ( stream_load.hasNext() ) {
 5534  0
                     adaptor.addChild(root_0, stream_load.nextTree());
 5535  
 
 5536  
                 }
 5537  128
                 stream_load.reset();
 5538  
 
 5539  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:112: ( clear )*
 5540  136
                 while ( stream_clear.hasNext() ) {
 5541  8
                     adaptor.addChild(root_0, stream_clear.nextTree());
 5542  
 
 5543  
                 }
 5544  128
                 stream_clear.reset();
 5545  
 
 5546  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:119: ( drop )*
 5547  136
                 while ( stream_drop.hasNext() ) {
 5548  8
                     adaptor.addChild(root_0, stream_drop.nextTree());
 5549  
 
 5550  
                 }
 5551  128
                 stream_drop.reset();
 5552  
 
 5553  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:125: ( add )*
 5554  128
                 while ( stream_add.hasNext() ) {
 5555  0
                     adaptor.addChild(root_0, stream_add.nextTree());
 5556  
 
 5557  
                 }
 5558  128
                 stream_add.reset();
 5559  
 
 5560  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:130: ( move )*
 5561  128
                 while ( stream_move.hasNext() ) {
 5562  0
                     adaptor.addChild(root_0, stream_move.nextTree());
 5563  
 
 5564  
                 }
 5565  128
                 stream_move.reset();
 5566  
 
 5567  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:136: ( copy )*
 5568  128
                 while ( stream_copy.hasNext() ) {
 5569  0
                     adaptor.addChild(root_0, stream_copy.nextTree());
 5570  
 
 5571  
                 }
 5572  128
                 stream_copy.reset();
 5573  
 
 5574  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:142: ( create )*
 5575  128
                 while ( stream_create.hasNext() ) {
 5576  0
                     adaptor.addChild(root_0, stream_create.nextTree());
 5577  
 
 5578  
                 }
 5579  128
                 stream_create.reset();
 5580  
 
 5581  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:150: ( insert )*
 5582  136
                 while ( stream_insert.hasNext() ) {
 5583  8
                     adaptor.addChild(root_0, stream_insert.nextTree());
 5584  
 
 5585  
                 }
 5586  128
                 stream_insert.reset();
 5587  
 
 5588  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:158: ( delete )*
 5589  152
                 while ( stream_delete.hasNext() ) {
 5590  24
                     adaptor.addChild(root_0, stream_delete.nextTree());
 5591  
 
 5592  
                 }
 5593  128
                 stream_delete.reset();
 5594  
 
 5595  
                 // com\\googlecode\\sparkleg\\Sparql.g:189:166: ( modify )*
 5596  208
                 while ( stream_modify.hasNext() ) {
 5597  80
                     adaptor.addChild(root_0, stream_modify.nextTree());
 5598  
 
 5599  
                 }
 5600  128
                 stream_modify.reset();
 5601  
 
 5602  
             }
 5603  
 
 5604  
 
 5605  128
             retval.tree = root_0;
 5606  
 
 5607  
             }
 5608  
 
 5609  128
             retval.stop = input.LT(-1);
 5610  
 
 5611  
 
 5612  128
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5613  128
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5614  
 
 5615  
         }
 5616  0
         catch (RecognitionException re) {
 5617  0
             reportError(re);
 5618  0
             recover(input,re);
 5619  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5620  
 
 5621  
         }
 5622  
 
 5623  0
         finally {
 5624  
                 // do for sure before leaving
 5625  128
         }
 5626  128
         return retval;
 5627  
     }
 5628  
     // $ANTLR end "update"
 5629  
 
 5630  
 
 5631  0
     public static class load_return extends ParserRuleReturnScope {
 5632  
         Object tree;
 5633  0
         public Object getTree() { return tree; }
 5634  
     };
 5635  
 
 5636  
 
 5637  
     // $ANTLR start "load"
 5638  
     // com\\googlecode\\sparkleg\\Sparql.g:192:1: load : LOAD ( SILENT )? iriRef ( INTO graphRef )? -> ^( LOAD ( SILENT )* iriRef ( graphRef )? ) ;
 5639  
     public final SparqlParser.load_return load() throws RecognitionException {
 5640  0
         SparqlParser.load_return retval = new SparqlParser.load_return();
 5641  0
         retval.start = input.LT(1);
 5642  
 
 5643  
 
 5644  0
         Object root_0 = null;
 5645  
 
 5646  0
         Token LOAD120=null;
 5647  0
         Token SILENT121=null;
 5648  0
         Token INTO123=null;
 5649  0
         SparqlParser.iriRef_return iriRef122 =null;
 5650  
 
 5651  0
         SparqlParser.graphRef_return graphRef124 =null;
 5652  
 
 5653  
 
 5654  0
         Object LOAD120_tree=null;
 5655  0
         Object SILENT121_tree=null;
 5656  0
         Object INTO123_tree=null;
 5657  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5658  0
         RewriteRuleTokenStream stream_INTO=new RewriteRuleTokenStream(adaptor,"token INTO");
 5659  0
         RewriteRuleTokenStream stream_LOAD=new RewriteRuleTokenStream(adaptor,"token LOAD");
 5660  0
         RewriteRuleSubtreeStream stream_graphRef=new RewriteRuleSubtreeStream(adaptor,"rule graphRef");
 5661  0
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 5662  
         try {
 5663  
             // com\\googlecode\\sparkleg\\Sparql.g:193:5: ( LOAD ( SILENT )? iriRef ( INTO graphRef )? -> ^( LOAD ( SILENT )* iriRef ( graphRef )? ) )
 5664  
             // com\\googlecode\\sparkleg\\Sparql.g:193:7: LOAD ( SILENT )? iriRef ( INTO graphRef )?
 5665  
             {
 5666  0
             LOAD120=(Token)match(input,LOAD,FOLLOW_LOAD_in_load1438);  
 5667  0
             stream_LOAD.add(LOAD120);
 5668  
 
 5669  
 
 5670  
             // com\\googlecode\\sparkleg\\Sparql.g:193:12: ( SILENT )?
 5671  0
             int alt41=2;
 5672  0
             switch ( input.LA(1) ) {
 5673  
                 case SILENT:
 5674  
                     {
 5675  0
                     alt41=1;
 5676  
                     }
 5677  
                     break;
 5678  
             }
 5679  
 
 5680  0
             switch (alt41) {
 5681  
                 case 1 :
 5682  
                     // com\\googlecode\\sparkleg\\Sparql.g:193:12: SILENT
 5683  
                     {
 5684  0
                     SILENT121=(Token)match(input,SILENT,FOLLOW_SILENT_in_load1440);  
 5685  0
                     stream_SILENT.add(SILENT121);
 5686  
 
 5687  
 
 5688  
                     }
 5689  
                     break;
 5690  
 
 5691  
             }
 5692  
 
 5693  
 
 5694  0
             pushFollow(FOLLOW_iriRef_in_load1443);
 5695  0
             iriRef122=iriRef();
 5696  
 
 5697  0
             state._fsp--;
 5698  
 
 5699  0
             stream_iriRef.add(iriRef122.getTree());
 5700  
 
 5701  
             // com\\googlecode\\sparkleg\\Sparql.g:193:27: ( INTO graphRef )?
 5702  0
             int alt42=2;
 5703  0
             switch ( input.LA(1) ) {
 5704  
                 case INTO:
 5705  
                     {
 5706  0
                     alt42=1;
 5707  
                     }
 5708  
                     break;
 5709  
             }
 5710  
 
 5711  0
             switch (alt42) {
 5712  
                 case 1 :
 5713  
                     // com\\googlecode\\sparkleg\\Sparql.g:193:28: INTO graphRef
 5714  
                     {
 5715  0
                     INTO123=(Token)match(input,INTO,FOLLOW_INTO_in_load1446);  
 5716  0
                     stream_INTO.add(INTO123);
 5717  
 
 5718  
 
 5719  0
                     pushFollow(FOLLOW_graphRef_in_load1448);
 5720  0
                     graphRef124=graphRef();
 5721  
 
 5722  0
                     state._fsp--;
 5723  
 
 5724  0
                     stream_graphRef.add(graphRef124.getTree());
 5725  
 
 5726  
                     }
 5727  
                     break;
 5728  
 
 5729  
             }
 5730  
 
 5731  
 
 5732  
             // AST REWRITE
 5733  
             // elements: iriRef, LOAD, SILENT, graphRef
 5734  
             // token labels: 
 5735  
             // rule labels: retval
 5736  
             // token list labels: 
 5737  
             // rule list labels: 
 5738  
             // wildcard labels: 
 5739  0
             retval.tree = root_0;
 5740  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5741  
 
 5742  0
             root_0 = (Object)adaptor.nil();
 5743  
             // 193:44: -> ^( LOAD ( SILENT )* iriRef ( graphRef )? )
 5744  
             {
 5745  
                 // com\\googlecode\\sparkleg\\Sparql.g:193:47: ^( LOAD ( SILENT )* iriRef ( graphRef )? )
 5746  
                 {
 5747  0
                 Object root_1 = (Object)adaptor.nil();
 5748  0
                 root_1 = (Object)adaptor.becomeRoot(
 5749  
                 stream_LOAD.nextNode()
 5750  
                 , root_1);
 5751  
 
 5752  
                 // com\\googlecode\\sparkleg\\Sparql.g:193:54: ( SILENT )*
 5753  0
                 while ( stream_SILENT.hasNext() ) {
 5754  0
                     adaptor.addChild(root_1, 
 5755  
                     stream_SILENT.nextNode()
 5756  
                     );
 5757  
 
 5758  
                 }
 5759  0
                 stream_SILENT.reset();
 5760  
 
 5761  0
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 5762  
 
 5763  
                 // com\\googlecode\\sparkleg\\Sparql.g:193:69: ( graphRef )?
 5764  0
                 if ( stream_graphRef.hasNext() ) {
 5765  0
                     adaptor.addChild(root_1, stream_graphRef.nextTree());
 5766  
 
 5767  
                 }
 5768  0
                 stream_graphRef.reset();
 5769  
 
 5770  0
                 adaptor.addChild(root_0, root_1);
 5771  
                 }
 5772  
 
 5773  
             }
 5774  
 
 5775  
 
 5776  0
             retval.tree = root_0;
 5777  
 
 5778  
             }
 5779  
 
 5780  0
             retval.stop = input.LT(-1);
 5781  
 
 5782  
 
 5783  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5784  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5785  
 
 5786  
         }
 5787  0
         catch (RecognitionException re) {
 5788  0
             reportError(re);
 5789  0
             recover(input,re);
 5790  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5791  
 
 5792  
         }
 5793  
 
 5794  0
         finally {
 5795  
                 // do for sure before leaving
 5796  0
         }
 5797  0
         return retval;
 5798  
     }
 5799  
     // $ANTLR end "load"
 5800  
 
 5801  
 
 5802  8
     public static class clear_return extends ParserRuleReturnScope {
 5803  
         Object tree;
 5804  8
         public Object getTree() { return tree; }
 5805  
     };
 5806  
 
 5807  
 
 5808  
     // $ANTLR start "clear"
 5809  
     // com\\googlecode\\sparkleg\\Sparql.g:196:1: clear : CLEAR ( SILENT )? graphRefAll -> ^( CLEAR ( SILENT )* graphRefAll ) ;
 5810  
     public final SparqlParser.clear_return clear() throws RecognitionException {
 5811  8
         SparqlParser.clear_return retval = new SparqlParser.clear_return();
 5812  8
         retval.start = input.LT(1);
 5813  
 
 5814  
 
 5815  8
         Object root_0 = null;
 5816  
 
 5817  8
         Token CLEAR125=null;
 5818  8
         Token SILENT126=null;
 5819  8
         SparqlParser.graphRefAll_return graphRefAll127 =null;
 5820  
 
 5821  
 
 5822  8
         Object CLEAR125_tree=null;
 5823  8
         Object SILENT126_tree=null;
 5824  8
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5825  8
         RewriteRuleTokenStream stream_CLEAR=new RewriteRuleTokenStream(adaptor,"token CLEAR");
 5826  8
         RewriteRuleSubtreeStream stream_graphRefAll=new RewriteRuleSubtreeStream(adaptor,"rule graphRefAll");
 5827  
         try {
 5828  
             // com\\googlecode\\sparkleg\\Sparql.g:197:5: ( CLEAR ( SILENT )? graphRefAll -> ^( CLEAR ( SILENT )* graphRefAll ) )
 5829  
             // com\\googlecode\\sparkleg\\Sparql.g:197:7: CLEAR ( SILENT )? graphRefAll
 5830  
             {
 5831  8
             CLEAR125=(Token)match(input,CLEAR,FOLLOW_CLEAR_in_clear1485);  
 5832  8
             stream_CLEAR.add(CLEAR125);
 5833  
 
 5834  
 
 5835  
             // com\\googlecode\\sparkleg\\Sparql.g:197:14: ( SILENT )?
 5836  8
             int alt43=2;
 5837  8
             switch ( input.LA(1) ) {
 5838  
                 case SILENT:
 5839  
                     {
 5840  0
                     alt43=1;
 5841  
                     }
 5842  
                     break;
 5843  
             }
 5844  
 
 5845  8
             switch (alt43) {
 5846  
                 case 1 :
 5847  
                     // com\\googlecode\\sparkleg\\Sparql.g:197:14: SILENT
 5848  
                     {
 5849  0
                     SILENT126=(Token)match(input,SILENT,FOLLOW_SILENT_in_clear1488);  
 5850  0
                     stream_SILENT.add(SILENT126);
 5851  
 
 5852  
 
 5853  
                     }
 5854  
                     break;
 5855  
 
 5856  
             }
 5857  
 
 5858  
 
 5859  8
             pushFollow(FOLLOW_graphRefAll_in_clear1491);
 5860  8
             graphRefAll127=graphRefAll();
 5861  
 
 5862  8
             state._fsp--;
 5863  
 
 5864  8
             stream_graphRefAll.add(graphRefAll127.getTree());
 5865  
 
 5866  
             // AST REWRITE
 5867  
             // elements: CLEAR, graphRefAll, SILENT
 5868  
             // token labels: 
 5869  
             // rule labels: retval
 5870  
             // token list labels: 
 5871  
             // rule list labels: 
 5872  
             // wildcard labels: 
 5873  8
             retval.tree = root_0;
 5874  8
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5875  
 
 5876  8
             root_0 = (Object)adaptor.nil();
 5877  
             // 197:34: -> ^( CLEAR ( SILENT )* graphRefAll )
 5878  
             {
 5879  
                 // com\\googlecode\\sparkleg\\Sparql.g:197:37: ^( CLEAR ( SILENT )* graphRefAll )
 5880  
                 {
 5881  8
                 Object root_1 = (Object)adaptor.nil();
 5882  8
                 root_1 = (Object)adaptor.becomeRoot(
 5883  
                 stream_CLEAR.nextNode()
 5884  
                 , root_1);
 5885  
 
 5886  
                 // com\\googlecode\\sparkleg\\Sparql.g:197:45: ( SILENT )*
 5887  8
                 while ( stream_SILENT.hasNext() ) {
 5888  0
                     adaptor.addChild(root_1, 
 5889  
                     stream_SILENT.nextNode()
 5890  
                     );
 5891  
 
 5892  
                 }
 5893  8
                 stream_SILENT.reset();
 5894  
 
 5895  8
                 adaptor.addChild(root_1, stream_graphRefAll.nextTree());
 5896  
 
 5897  8
                 adaptor.addChild(root_0, root_1);
 5898  
                 }
 5899  
 
 5900  
             }
 5901  
 
 5902  
 
 5903  8
             retval.tree = root_0;
 5904  
 
 5905  
             }
 5906  
 
 5907  8
             retval.stop = input.LT(-1);
 5908  
 
 5909  
 
 5910  8
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5911  8
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5912  
 
 5913  
         }
 5914  0
         catch (RecognitionException re) {
 5915  0
             reportError(re);
 5916  0
             recover(input,re);
 5917  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5918  
 
 5919  
         }
 5920  
 
 5921  0
         finally {
 5922  
                 // do for sure before leaving
 5923  8
         }
 5924  8
         return retval;
 5925  
     }
 5926  
     // $ANTLR end "clear"
 5927  
 
 5928  
 
 5929  8
     public static class drop_return extends ParserRuleReturnScope {
 5930  
         Object tree;
 5931  8
         public Object getTree() { return tree; }
 5932  
     };
 5933  
 
 5934  
 
 5935  
     // $ANTLR start "drop"
 5936  
     // com\\googlecode\\sparkleg\\Sparql.g:200:1: drop : DROP ( SILENT )? graphRefAll -> ^( DROP ( SILENT )* graphRefAll ) ;
 5937  
     public final SparqlParser.drop_return drop() throws RecognitionException {
 5938  8
         SparqlParser.drop_return retval = new SparqlParser.drop_return();
 5939  8
         retval.start = input.LT(1);
 5940  
 
 5941  
 
 5942  8
         Object root_0 = null;
 5943  
 
 5944  8
         Token DROP128=null;
 5945  8
         Token SILENT129=null;
 5946  8
         SparqlParser.graphRefAll_return graphRefAll130 =null;
 5947  
 
 5948  
 
 5949  8
         Object DROP128_tree=null;
 5950  8
         Object SILENT129_tree=null;
 5951  8
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5952  8
         RewriteRuleTokenStream stream_DROP=new RewriteRuleTokenStream(adaptor,"token DROP");
 5953  8
         RewriteRuleSubtreeStream stream_graphRefAll=new RewriteRuleSubtreeStream(adaptor,"rule graphRefAll");
 5954  
         try {
 5955  
             // com\\googlecode\\sparkleg\\Sparql.g:201:5: ( DROP ( SILENT )? graphRefAll -> ^( DROP ( SILENT )* graphRefAll ) )
 5956  
             // com\\googlecode\\sparkleg\\Sparql.g:201:7: DROP ( SILENT )? graphRefAll
 5957  
             {
 5958  8
             DROP128=(Token)match(input,DROP,FOLLOW_DROP_in_drop1523);  
 5959  8
             stream_DROP.add(DROP128);
 5960  
 
 5961  
 
 5962  
             // com\\googlecode\\sparkleg\\Sparql.g:201:12: ( SILENT )?
 5963  8
             int alt44=2;
 5964  8
             switch ( input.LA(1) ) {
 5965  
                 case SILENT:
 5966  
                     {
 5967  0
                     alt44=1;
 5968  
                     }
 5969  
                     break;
 5970  
             }
 5971  
 
 5972  8
             switch (alt44) {
 5973  
                 case 1 :
 5974  
                     // com\\googlecode\\sparkleg\\Sparql.g:201:12: SILENT
 5975  
                     {
 5976  0
                     SILENT129=(Token)match(input,SILENT,FOLLOW_SILENT_in_drop1525);  
 5977  0
                     stream_SILENT.add(SILENT129);
 5978  
 
 5979  
 
 5980  
                     }
 5981  
                     break;
 5982  
 
 5983  
             }
 5984  
 
 5985  
 
 5986  8
             pushFollow(FOLLOW_graphRefAll_in_drop1528);
 5987  8
             graphRefAll130=graphRefAll();
 5988  
 
 5989  8
             state._fsp--;
 5990  
 
 5991  8
             stream_graphRefAll.add(graphRefAll130.getTree());
 5992  
 
 5993  
             // AST REWRITE
 5994  
             // elements: SILENT, DROP, graphRefAll
 5995  
             // token labels: 
 5996  
             // rule labels: retval
 5997  
             // token list labels: 
 5998  
             // rule list labels: 
 5999  
             // wildcard labels: 
 6000  8
             retval.tree = root_0;
 6001  8
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6002  
 
 6003  8
             root_0 = (Object)adaptor.nil();
 6004  
             // 201:32: -> ^( DROP ( SILENT )* graphRefAll )
 6005  
             {
 6006  
                 // com\\googlecode\\sparkleg\\Sparql.g:201:35: ^( DROP ( SILENT )* graphRefAll )
 6007  
                 {
 6008  8
                 Object root_1 = (Object)adaptor.nil();
 6009  8
                 root_1 = (Object)adaptor.becomeRoot(
 6010  
                 stream_DROP.nextNode()
 6011  
                 , root_1);
 6012  
 
 6013  
                 // com\\googlecode\\sparkleg\\Sparql.g:201:42: ( SILENT )*
 6014  8
                 while ( stream_SILENT.hasNext() ) {
 6015  0
                     adaptor.addChild(root_1, 
 6016  
                     stream_SILENT.nextNode()
 6017  
                     );
 6018  
 
 6019  
                 }
 6020  8
                 stream_SILENT.reset();
 6021  
 
 6022  8
                 adaptor.addChild(root_1, stream_graphRefAll.nextTree());
 6023  
 
 6024  8
                 adaptor.addChild(root_0, root_1);
 6025  
                 }
 6026  
 
 6027  
             }
 6028  
 
 6029  
 
 6030  8
             retval.tree = root_0;
 6031  
 
 6032  
             }
 6033  
 
 6034  8
             retval.stop = input.LT(-1);
 6035  
 
 6036  
 
 6037  8
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6038  8
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6039  
 
 6040  
         }
 6041  0
         catch (RecognitionException re) {
 6042  0
             reportError(re);
 6043  0
             recover(input,re);
 6044  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6045  
 
 6046  
         }
 6047  
 
 6048  0
         finally {
 6049  
                 // do for sure before leaving
 6050  8
         }
 6051  8
         return retval;
 6052  
     }
 6053  
     // $ANTLR end "drop"
 6054  
 
 6055  
 
 6056  0
     public static class create_return extends ParserRuleReturnScope {
 6057  
         Object tree;
 6058  0
         public Object getTree() { return tree; }
 6059  
     };
 6060  
 
 6061  
 
 6062  
     // $ANTLR start "create"
 6063  
     // com\\googlecode\\sparkleg\\Sparql.g:204:1: create : CREATE ( SILENT )? graphRef -> ^( CREATE ( SILENT )* graphRef ) ;
 6064  
     public final SparqlParser.create_return create() throws RecognitionException {
 6065  0
         SparqlParser.create_return retval = new SparqlParser.create_return();
 6066  0
         retval.start = input.LT(1);
 6067  
 
 6068  
 
 6069  0
         Object root_0 = null;
 6070  
 
 6071  0
         Token CREATE131=null;
 6072  0
         Token SILENT132=null;
 6073  0
         SparqlParser.graphRef_return graphRef133 =null;
 6074  
 
 6075  
 
 6076  0
         Object CREATE131_tree=null;
 6077  0
         Object SILENT132_tree=null;
 6078  0
         RewriteRuleTokenStream stream_CREATE=new RewriteRuleTokenStream(adaptor,"token CREATE");
 6079  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6080  0
         RewriteRuleSubtreeStream stream_graphRef=new RewriteRuleSubtreeStream(adaptor,"rule graphRef");
 6081  
         try {
 6082  
             // com\\googlecode\\sparkleg\\Sparql.g:205:5: ( CREATE ( SILENT )? graphRef -> ^( CREATE ( SILENT )* graphRef ) )
 6083  
             // com\\googlecode\\sparkleg\\Sparql.g:205:7: CREATE ( SILENT )? graphRef
 6084  
             {
 6085  0
             CREATE131=(Token)match(input,CREATE,FOLLOW_CREATE_in_create1557);  
 6086  0
             stream_CREATE.add(CREATE131);
 6087  
 
 6088  
 
 6089  
             // com\\googlecode\\sparkleg\\Sparql.g:205:14: ( SILENT )?
 6090  0
             int alt45=2;
 6091  0
             switch ( input.LA(1) ) {
 6092  
                 case SILENT:
 6093  
                     {
 6094  0
                     alt45=1;
 6095  
                     }
 6096  
                     break;
 6097  
             }
 6098  
 
 6099  0
             switch (alt45) {
 6100  
                 case 1 :
 6101  
                     // com\\googlecode\\sparkleg\\Sparql.g:205:14: SILENT
 6102  
                     {
 6103  0
                     SILENT132=(Token)match(input,SILENT,FOLLOW_SILENT_in_create1559);  
 6104  0
                     stream_SILENT.add(SILENT132);
 6105  
 
 6106  
 
 6107  
                     }
 6108  
                     break;
 6109  
 
 6110  
             }
 6111  
 
 6112  
 
 6113  0
             pushFollow(FOLLOW_graphRef_in_create1562);
 6114  0
             graphRef133=graphRef();
 6115  
 
 6116  0
             state._fsp--;
 6117  
 
 6118  0
             stream_graphRef.add(graphRef133.getTree());
 6119  
 
 6120  
             // AST REWRITE
 6121  
             // elements: graphRef, SILENT, CREATE
 6122  
             // token labels: 
 6123  
             // rule labels: retval
 6124  
             // token list labels: 
 6125  
             // rule list labels: 
 6126  
             // wildcard labels: 
 6127  0
             retval.tree = root_0;
 6128  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6129  
 
 6130  0
             root_0 = (Object)adaptor.nil();
 6131  
             // 205:31: -> ^( CREATE ( SILENT )* graphRef )
 6132  
             {
 6133  
                 // com\\googlecode\\sparkleg\\Sparql.g:205:34: ^( CREATE ( SILENT )* graphRef )
 6134  
                 {
 6135  0
                 Object root_1 = (Object)adaptor.nil();
 6136  0
                 root_1 = (Object)adaptor.becomeRoot(
 6137  
                 stream_CREATE.nextNode()
 6138  
                 , root_1);
 6139  
 
 6140  
                 // com\\googlecode\\sparkleg\\Sparql.g:205:43: ( SILENT )*
 6141  0
                 while ( stream_SILENT.hasNext() ) {
 6142  0
                     adaptor.addChild(root_1, 
 6143  
                     stream_SILENT.nextNode()
 6144  
                     );
 6145  
 
 6146  
                 }
 6147  0
                 stream_SILENT.reset();
 6148  
 
 6149  0
                 adaptor.addChild(root_1, stream_graphRef.nextTree());
 6150  
 
 6151  0
                 adaptor.addChild(root_0, root_1);
 6152  
                 }
 6153  
 
 6154  
             }
 6155  
 
 6156  
 
 6157  0
             retval.tree = root_0;
 6158  
 
 6159  
             }
 6160  
 
 6161  0
             retval.stop = input.LT(-1);
 6162  
 
 6163  
 
 6164  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6165  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6166  
 
 6167  
         }
 6168  0
         catch (RecognitionException re) {
 6169  0
             reportError(re);
 6170  0
             recover(input,re);
 6171  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6172  
 
 6173  
         }
 6174  
 
 6175  0
         finally {
 6176  
                 // do for sure before leaving
 6177  0
         }
 6178  0
         return retval;
 6179  
     }
 6180  
     // $ANTLR end "create"
 6181  
 
 6182  
 
 6183  0
     public static class add_return extends ParserRuleReturnScope {
 6184  
         Object tree;
 6185  0
         public Object getTree() { return tree; }
 6186  
     };
 6187  
 
 6188  
 
 6189  
     // $ANTLR start "add"
 6190  
     // com\\googlecode\\sparkleg\\Sparql.g:208:1: add : ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( ADD ( SILENT )* $from $to) ;
 6191  
     public final SparqlParser.add_return add() throws RecognitionException {
 6192  0
         SparqlParser.add_return retval = new SparqlParser.add_return();
 6193  0
         retval.start = input.LT(1);
 6194  
 
 6195  
 
 6196  0
         Object root_0 = null;
 6197  
 
 6198  0
         Token ADD134=null;
 6199  0
         Token SILENT135=null;
 6200  0
         Token TO136=null;
 6201  0
         SparqlParser.graphOrDefault_return from =null;
 6202  
 
 6203  0
         SparqlParser.graphOrDefault_return to =null;
 6204  
 
 6205  
 
 6206  0
         Object ADD134_tree=null;
 6207  0
         Object SILENT135_tree=null;
 6208  0
         Object TO136_tree=null;
 6209  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6210  0
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6211  0
         RewriteRuleTokenStream stream_ADD=new RewriteRuleTokenStream(adaptor,"token ADD");
 6212  0
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6213  
         try {
 6214  
             // com\\googlecode\\sparkleg\\Sparql.g:209:5: ( ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( ADD ( SILENT )* $from $to) )
 6215  
             // com\\googlecode\\sparkleg\\Sparql.g:209:7: ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6216  
             {
 6217  0
             ADD134=(Token)match(input,ADD,FOLLOW_ADD_in_add1594);  
 6218  0
             stream_ADD.add(ADD134);
 6219  
 
 6220  
 
 6221  
             // com\\googlecode\\sparkleg\\Sparql.g:209:11: ( SILENT )?
 6222  0
             int alt46=2;
 6223  0
             switch ( input.LA(1) ) {
 6224  
                 case SILENT:
 6225  
                     {
 6226  0
                     alt46=1;
 6227  
                     }
 6228  
                     break;
 6229  
             }
 6230  
 
 6231  0
             switch (alt46) {
 6232  
                 case 1 :
 6233  
                     // com\\googlecode\\sparkleg\\Sparql.g:209:11: SILENT
 6234  
                     {
 6235  0
                     SILENT135=(Token)match(input,SILENT,FOLLOW_SILENT_in_add1596);  
 6236  0
                     stream_SILENT.add(SILENT135);
 6237  
 
 6238  
 
 6239  
                     }
 6240  
                     break;
 6241  
 
 6242  
             }
 6243  
 
 6244  
 
 6245  0
             pushFollow(FOLLOW_graphOrDefault_in_add1601);
 6246  0
             from=graphOrDefault();
 6247  
 
 6248  0
             state._fsp--;
 6249  
 
 6250  0
             stream_graphOrDefault.add(from.getTree());
 6251  
 
 6252  0
             TO136=(Token)match(input,TO,FOLLOW_TO_in_add1603);  
 6253  0
             stream_TO.add(TO136);
 6254  
 
 6255  
 
 6256  0
             pushFollow(FOLLOW_graphOrDefault_in_add1607);
 6257  0
             to=graphOrDefault();
 6258  
 
 6259  0
             state._fsp--;
 6260  
 
 6261  0
             stream_graphOrDefault.add(to.getTree());
 6262  
 
 6263  
             // AST REWRITE
 6264  
             // elements: from, SILENT, ADD, to
 6265  
             // token labels: 
 6266  
             // rule labels: to, retval, from
 6267  
             // token list labels: 
 6268  
             // rule list labels: 
 6269  
             // wildcard labels: 
 6270  0
             retval.tree = root_0;
 6271  0
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6272  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6273  0
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6274  
 
 6275  0
             root_0 = (Object)adaptor.nil();
 6276  
             // 209:60: -> ^( ADD ( SILENT )* $from $to)
 6277  
             {
 6278  
                 // com\\googlecode\\sparkleg\\Sparql.g:209:63: ^( ADD ( SILENT )* $from $to)
 6279  
                 {
 6280  0
                 Object root_1 = (Object)adaptor.nil();
 6281  0
                 root_1 = (Object)adaptor.becomeRoot(
 6282  
                 stream_ADD.nextNode()
 6283  
                 , root_1);
 6284  
 
 6285  
                 // com\\googlecode\\sparkleg\\Sparql.g:209:69: ( SILENT )*
 6286  0
                 while ( stream_SILENT.hasNext() ) {
 6287  0
                     adaptor.addChild(root_1, 
 6288  
                     stream_SILENT.nextNode()
 6289  
                     );
 6290  
 
 6291  
                 }
 6292  0
                 stream_SILENT.reset();
 6293  
 
 6294  0
                 adaptor.addChild(root_1, stream_from.nextTree());
 6295  
 
 6296  0
                 adaptor.addChild(root_1, stream_to.nextTree());
 6297  
 
 6298  0
                 adaptor.addChild(root_0, root_1);
 6299  
                 }
 6300  
 
 6301  
             }
 6302  
 
 6303  
 
 6304  0
             retval.tree = root_0;
 6305  
 
 6306  
             }
 6307  
 
 6308  0
             retval.stop = input.LT(-1);
 6309  
 
 6310  
 
 6311  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6312  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6313  
 
 6314  
         }
 6315  0
         catch (RecognitionException re) {
 6316  0
             reportError(re);
 6317  0
             recover(input,re);
 6318  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6319  
 
 6320  
         }
 6321  
 
 6322  0
         finally {
 6323  
                 // do for sure before leaving
 6324  0
         }
 6325  0
         return retval;
 6326  
     }
 6327  
     // $ANTLR end "add"
 6328  
 
 6329  
 
 6330  0
     public static class move_return extends ParserRuleReturnScope {
 6331  
         Object tree;
 6332  0
         public Object getTree() { return tree; }
 6333  
     };
 6334  
 
 6335  
 
 6336  
     // $ANTLR start "move"
 6337  
     // com\\googlecode\\sparkleg\\Sparql.g:212:1: move : MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( MOVE ( SILENT )* $from $to) ;
 6338  
     public final SparqlParser.move_return move() throws RecognitionException {
 6339  0
         SparqlParser.move_return retval = new SparqlParser.move_return();
 6340  0
         retval.start = input.LT(1);
 6341  
 
 6342  
 
 6343  0
         Object root_0 = null;
 6344  
 
 6345  0
         Token MOVE137=null;
 6346  0
         Token SILENT138=null;
 6347  0
         Token TO139=null;
 6348  0
         SparqlParser.graphOrDefault_return from =null;
 6349  
 
 6350  0
         SparqlParser.graphOrDefault_return to =null;
 6351  
 
 6352  
 
 6353  0
         Object MOVE137_tree=null;
 6354  0
         Object SILENT138_tree=null;
 6355  0
         Object TO139_tree=null;
 6356  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6357  0
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6358  0
         RewriteRuleTokenStream stream_MOVE=new RewriteRuleTokenStream(adaptor,"token MOVE");
 6359  0
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6360  
         try {
 6361  
             // com\\googlecode\\sparkleg\\Sparql.g:213:5: ( MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( MOVE ( SILENT )* $from $to) )
 6362  
             // com\\googlecode\\sparkleg\\Sparql.g:213:7: MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6363  
             {
 6364  0
             MOVE137=(Token)match(input,MOVE,FOLLOW_MOVE_in_move1643);  
 6365  0
             stream_MOVE.add(MOVE137);
 6366  
 
 6367  
 
 6368  
             // com\\googlecode\\sparkleg\\Sparql.g:213:12: ( SILENT )?
 6369  0
             int alt47=2;
 6370  0
             switch ( input.LA(1) ) {
 6371  
                 case SILENT:
 6372  
                     {
 6373  0
                     alt47=1;
 6374  
                     }
 6375  
                     break;
 6376  
             }
 6377  
 
 6378  0
             switch (alt47) {
 6379  
                 case 1 :
 6380  
                     // com\\googlecode\\sparkleg\\Sparql.g:213:12: SILENT
 6381  
                     {
 6382  0
                     SILENT138=(Token)match(input,SILENT,FOLLOW_SILENT_in_move1645);  
 6383  0
                     stream_SILENT.add(SILENT138);
 6384  
 
 6385  
 
 6386  
                     }
 6387  
                     break;
 6388  
 
 6389  
             }
 6390  
 
 6391  
 
 6392  0
             pushFollow(FOLLOW_graphOrDefault_in_move1650);
 6393  0
             from=graphOrDefault();
 6394  
 
 6395  0
             state._fsp--;
 6396  
 
 6397  0
             stream_graphOrDefault.add(from.getTree());
 6398  
 
 6399  0
             TO139=(Token)match(input,TO,FOLLOW_TO_in_move1652);  
 6400  0
             stream_TO.add(TO139);
 6401  
 
 6402  
 
 6403  0
             pushFollow(FOLLOW_graphOrDefault_in_move1656);
 6404  0
             to=graphOrDefault();
 6405  
 
 6406  0
             state._fsp--;
 6407  
 
 6408  0
             stream_graphOrDefault.add(to.getTree());
 6409  
 
 6410  
             // AST REWRITE
 6411  
             // elements: MOVE, to, SILENT, from
 6412  
             // token labels: 
 6413  
             // rule labels: to, retval, from
 6414  
             // token list labels: 
 6415  
             // rule list labels: 
 6416  
             // wildcard labels: 
 6417  0
             retval.tree = root_0;
 6418  0
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6419  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6420  0
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6421  
 
 6422  0
             root_0 = (Object)adaptor.nil();
 6423  
             // 213:61: -> ^( MOVE ( SILENT )* $from $to)
 6424  
             {
 6425  
                 // com\\googlecode\\sparkleg\\Sparql.g:213:64: ^( MOVE ( SILENT )* $from $to)
 6426  
                 {
 6427  0
                 Object root_1 = (Object)adaptor.nil();
 6428  0
                 root_1 = (Object)adaptor.becomeRoot(
 6429  
                 stream_MOVE.nextNode()
 6430  
                 , root_1);
 6431  
 
 6432  
                 // com\\googlecode\\sparkleg\\Sparql.g:213:71: ( SILENT )*
 6433  0
                 while ( stream_SILENT.hasNext() ) {
 6434  0
                     adaptor.addChild(root_1, 
 6435  
                     stream_SILENT.nextNode()
 6436  
                     );
 6437  
 
 6438  
                 }
 6439  0
                 stream_SILENT.reset();
 6440  
 
 6441  0
                 adaptor.addChild(root_1, stream_from.nextTree());
 6442  
 
 6443  0
                 adaptor.addChild(root_1, stream_to.nextTree());
 6444  
 
 6445  0
                 adaptor.addChild(root_0, root_1);
 6446  
                 }
 6447  
 
 6448  
             }
 6449  
 
 6450  
 
 6451  0
             retval.tree = root_0;
 6452  
 
 6453  
             }
 6454  
 
 6455  0
             retval.stop = input.LT(-1);
 6456  
 
 6457  
 
 6458  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6459  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6460  
 
 6461  
         }
 6462  0
         catch (RecognitionException re) {
 6463  0
             reportError(re);
 6464  0
             recover(input,re);
 6465  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6466  
 
 6467  
         }
 6468  
 
 6469  0
         finally {
 6470  
                 // do for sure before leaving
 6471  0
         }
 6472  0
         return retval;
 6473  
     }
 6474  
     // $ANTLR end "move"
 6475  
 
 6476  
 
 6477  0
     public static class copy_return extends ParserRuleReturnScope {
 6478  
         Object tree;
 6479  0
         public Object getTree() { return tree; }
 6480  
     };
 6481  
 
 6482  
 
 6483  
     // $ANTLR start "copy"
 6484  
     // com\\googlecode\\sparkleg\\Sparql.g:216:1: copy : COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( COPY ( SILENT )* $from $to) ;
 6485  
     public final SparqlParser.copy_return copy() throws RecognitionException {
 6486  0
         SparqlParser.copy_return retval = new SparqlParser.copy_return();
 6487  0
         retval.start = input.LT(1);
 6488  
 
 6489  
 
 6490  0
         Object root_0 = null;
 6491  
 
 6492  0
         Token COPY140=null;
 6493  0
         Token SILENT141=null;
 6494  0
         Token TO142=null;
 6495  0
         SparqlParser.graphOrDefault_return from =null;
 6496  
 
 6497  0
         SparqlParser.graphOrDefault_return to =null;
 6498  
 
 6499  
 
 6500  0
         Object COPY140_tree=null;
 6501  0
         Object SILENT141_tree=null;
 6502  0
         Object TO142_tree=null;
 6503  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6504  0
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6505  0
         RewriteRuleTokenStream stream_COPY=new RewriteRuleTokenStream(adaptor,"token COPY");
 6506  0
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6507  
         try {
 6508  
             // com\\googlecode\\sparkleg\\Sparql.g:217:5: ( COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( COPY ( SILENT )* $from $to) )
 6509  
             // com\\googlecode\\sparkleg\\Sparql.g:217:7: COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6510  
             {
 6511  0
             COPY140=(Token)match(input,COPY,FOLLOW_COPY_in_copy1692);  
 6512  0
             stream_COPY.add(COPY140);
 6513  
 
 6514  
 
 6515  
             // com\\googlecode\\sparkleg\\Sparql.g:217:12: ( SILENT )?
 6516  0
             int alt48=2;
 6517  0
             switch ( input.LA(1) ) {
 6518  
                 case SILENT:
 6519  
                     {
 6520  0
                     alt48=1;
 6521  
                     }
 6522  
                     break;
 6523  
             }
 6524  
 
 6525  0
             switch (alt48) {
 6526  
                 case 1 :
 6527  
                     // com\\googlecode\\sparkleg\\Sparql.g:217:12: SILENT
 6528  
                     {
 6529  0
                     SILENT141=(Token)match(input,SILENT,FOLLOW_SILENT_in_copy1694);  
 6530  0
                     stream_SILENT.add(SILENT141);
 6531  
 
 6532  
 
 6533  
                     }
 6534  
                     break;
 6535  
 
 6536  
             }
 6537  
 
 6538  
 
 6539  0
             pushFollow(FOLLOW_graphOrDefault_in_copy1699);
 6540  0
             from=graphOrDefault();
 6541  
 
 6542  0
             state._fsp--;
 6543  
 
 6544  0
             stream_graphOrDefault.add(from.getTree());
 6545  
 
 6546  0
             TO142=(Token)match(input,TO,FOLLOW_TO_in_copy1701);  
 6547  0
             stream_TO.add(TO142);
 6548  
 
 6549  
 
 6550  0
             pushFollow(FOLLOW_graphOrDefault_in_copy1705);
 6551  0
             to=graphOrDefault();
 6552  
 
 6553  0
             state._fsp--;
 6554  
 
 6555  0
             stream_graphOrDefault.add(to.getTree());
 6556  
 
 6557  
             // AST REWRITE
 6558  
             // elements: SILENT, to, from, COPY
 6559  
             // token labels: 
 6560  
             // rule labels: to, retval, from
 6561  
             // token list labels: 
 6562  
             // rule list labels: 
 6563  
             // wildcard labels: 
 6564  0
             retval.tree = root_0;
 6565  0
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6566  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6567  0
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6568  
 
 6569  0
             root_0 = (Object)adaptor.nil();
 6570  
             // 217:61: -> ^( COPY ( SILENT )* $from $to)
 6571  
             {
 6572  
                 // com\\googlecode\\sparkleg\\Sparql.g:217:64: ^( COPY ( SILENT )* $from $to)
 6573  
                 {
 6574  0
                 Object root_1 = (Object)adaptor.nil();
 6575  0
                 root_1 = (Object)adaptor.becomeRoot(
 6576  
                 stream_COPY.nextNode()
 6577  
                 , root_1);
 6578  
 
 6579  
                 // com\\googlecode\\sparkleg\\Sparql.g:217:71: ( SILENT )*
 6580  0
                 while ( stream_SILENT.hasNext() ) {
 6581  0
                     adaptor.addChild(root_1, 
 6582  
                     stream_SILENT.nextNode()
 6583  
                     );
 6584  
 
 6585  
                 }
 6586  0
                 stream_SILENT.reset();
 6587  
 
 6588  0
                 adaptor.addChild(root_1, stream_from.nextTree());
 6589  
 
 6590  0
                 adaptor.addChild(root_1, stream_to.nextTree());
 6591  
 
 6592  0
                 adaptor.addChild(root_0, root_1);
 6593  
                 }
 6594  
 
 6595  
             }
 6596  
 
 6597  
 
 6598  0
             retval.tree = root_0;
 6599  
 
 6600  
             }
 6601  
 
 6602  0
             retval.stop = input.LT(-1);
 6603  
 
 6604  
 
 6605  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6606  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6607  
 
 6608  
         }
 6609  0
         catch (RecognitionException re) {
 6610  0
             reportError(re);
 6611  0
             recover(input,re);
 6612  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6613  
 
 6614  
         }
 6615  
 
 6616  0
         finally {
 6617  
                 // do for sure before leaving
 6618  0
         }
 6619  0
         return retval;
 6620  
     }
 6621  
     // $ANTLR end "copy"
 6622  
 
 6623  
 
 6624  8
     public static class insert_return extends ParserRuleReturnScope {
 6625  
         Object tree;
 6626  8
         public Object getTree() { return tree; }
 6627  
     };
 6628  
 
 6629  
 
 6630  
     // $ANTLR start "insert"
 6631  
     // com\\googlecode\\sparkleg\\Sparql.g:220:1: insert : INSERT DATA quadPattern -> ^( INSERT DATA quadPattern ) ;
 6632  
     public final SparqlParser.insert_return insert() throws RecognitionException {
 6633  8
         SparqlParser.insert_return retval = new SparqlParser.insert_return();
 6634  8
         retval.start = input.LT(1);
 6635  
 
 6636  
 
 6637  8
         Object root_0 = null;
 6638  
 
 6639  8
         Token INSERT143=null;
 6640  8
         Token DATA144=null;
 6641  8
         SparqlParser.quadPattern_return quadPattern145 =null;
 6642  
 
 6643  
 
 6644  8
         Object INSERT143_tree=null;
 6645  8
         Object DATA144_tree=null;
 6646  8
         RewriteRuleTokenStream stream_INSERT=new RewriteRuleTokenStream(adaptor,"token INSERT");
 6647  8
         RewriteRuleTokenStream stream_DATA=new RewriteRuleTokenStream(adaptor,"token DATA");
 6648  8
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6649  
         try {
 6650  
             // com\\googlecode\\sparkleg\\Sparql.g:221:5: ( INSERT DATA quadPattern -> ^( INSERT DATA quadPattern ) )
 6651  
             // com\\googlecode\\sparkleg\\Sparql.g:221:7: INSERT DATA quadPattern
 6652  
             {
 6653  8
             INSERT143=(Token)match(input,INSERT,FOLLOW_INSERT_in_insert1737);  
 6654  8
             stream_INSERT.add(INSERT143);
 6655  
 
 6656  
 
 6657  8
             DATA144=(Token)match(input,DATA,FOLLOW_DATA_in_insert1739);  
 6658  8
             stream_DATA.add(DATA144);
 6659  
 
 6660  
 
 6661  8
             pushFollow(FOLLOW_quadPattern_in_insert1741);
 6662  8
             quadPattern145=quadPattern();
 6663  
 
 6664  8
             state._fsp--;
 6665  
 
 6666  8
             stream_quadPattern.add(quadPattern145.getTree());
 6667  
 
 6668  
             // AST REWRITE
 6669  
             // elements: DATA, INSERT, quadPattern
 6670  
             // token labels: 
 6671  
             // rule labels: retval
 6672  
             // token list labels: 
 6673  
             // rule list labels: 
 6674  
             // wildcard labels: 
 6675  8
             retval.tree = root_0;
 6676  8
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6677  
 
 6678  8
             root_0 = (Object)adaptor.nil();
 6679  
             // 221:31: -> ^( INSERT DATA quadPattern )
 6680  
             {
 6681  
                 // com\\googlecode\\sparkleg\\Sparql.g:221:34: ^( INSERT DATA quadPattern )
 6682  
                 {
 6683  8
                 Object root_1 = (Object)adaptor.nil();
 6684  8
                 root_1 = (Object)adaptor.becomeRoot(
 6685  
                 stream_INSERT.nextNode()
 6686  
                 , root_1);
 6687  
 
 6688  8
                 adaptor.addChild(root_1, 
 6689  
                 stream_DATA.nextNode()
 6690  
                 );
 6691  
 
 6692  8
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 6693  
 
 6694  8
                 adaptor.addChild(root_0, root_1);
 6695  
                 }
 6696  
 
 6697  
             }
 6698  
 
 6699  
 
 6700  8
             retval.tree = root_0;
 6701  
 
 6702  
             }
 6703  
 
 6704  8
             retval.stop = input.LT(-1);
 6705  
 
 6706  
 
 6707  8
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6708  8
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6709  
 
 6710  
         }
 6711  0
         catch (RecognitionException re) {
 6712  0
             reportError(re);
 6713  0
             recover(input,re);
 6714  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6715  
 
 6716  
         }
 6717  
 
 6718  0
         finally {
 6719  
                 // do for sure before leaving
 6720  8
         }
 6721  8
         return retval;
 6722  
     }
 6723  
     // $ANTLR end "insert"
 6724  
 
 6725  
 
 6726  24
     public static class delete_return extends ParserRuleReturnScope {
 6727  
         Object tree;
 6728  24
         public Object getTree() { return tree; }
 6729  
     };
 6730  
 
 6731  
 
 6732  
     // $ANTLR start "delete"
 6733  
     // com\\googlecode\\sparkleg\\Sparql.g:224:1: delete : DELETE ( deleteData | deleteWhere ) ;
 6734  
     public final SparqlParser.delete_return delete() throws RecognitionException {
 6735  24
         SparqlParser.delete_return retval = new SparqlParser.delete_return();
 6736  24
         retval.start = input.LT(1);
 6737  
 
 6738  
 
 6739  24
         Object root_0 = null;
 6740  
 
 6741  24
         Token DELETE146=null;
 6742  24
         SparqlParser.deleteData_return deleteData147 =null;
 6743  
 
 6744  24
         SparqlParser.deleteWhere_return deleteWhere148 =null;
 6745  
 
 6746  
 
 6747  24
         Object DELETE146_tree=null;
 6748  
 
 6749  
         try {
 6750  
             // com\\googlecode\\sparkleg\\Sparql.g:225:5: ( DELETE ( deleteData | deleteWhere ) )
 6751  
             // com\\googlecode\\sparkleg\\Sparql.g:225:7: DELETE ( deleteData | deleteWhere )
 6752  
             {
 6753  24
             root_0 = (Object)adaptor.nil();
 6754  
 
 6755  
 
 6756  24
             DELETE146=(Token)match(input,DELETE,FOLLOW_DELETE_in_delete1775); 
 6757  24
             DELETE146_tree = 
 6758  
             (Object)adaptor.create(DELETE146)
 6759  
             ;
 6760  24
             adaptor.addChild(root_0, DELETE146_tree);
 6761  
 
 6762  
 
 6763  
             // com\\googlecode\\sparkleg\\Sparql.g:225:14: ( deleteData | deleteWhere )
 6764  24
             int alt49=2;
 6765  24
             switch ( input.LA(1) ) {
 6766  
             case DATA:
 6767  
                 {
 6768  12
                 alt49=1;
 6769  
                 }
 6770  12
                 break;
 6771  
             case WHERE:
 6772  
                 {
 6773  12
                 alt49=2;
 6774  
                 }
 6775  12
                 break;
 6776  
             default:
 6777  0
                 NoViableAltException nvae =
 6778  
                     new NoViableAltException("", 49, 0, input);
 6779  
 
 6780  0
                 throw nvae;
 6781  
 
 6782  
             }
 6783  
 
 6784  24
             switch (alt49) {
 6785  
                 case 1 :
 6786  
                     // com\\googlecode\\sparkleg\\Sparql.g:225:15: deleteData
 6787  
                     {
 6788  12
                     pushFollow(FOLLOW_deleteData_in_delete1778);
 6789  12
                     deleteData147=deleteData();
 6790  
 
 6791  12
                     state._fsp--;
 6792  
 
 6793  12
                     adaptor.addChild(root_0, deleteData147.getTree());
 6794  
 
 6795  
                     }
 6796  12
                     break;
 6797  
                 case 2 :
 6798  
                     // com\\googlecode\\sparkleg\\Sparql.g:225:28: deleteWhere
 6799  
                     {
 6800  12
                     pushFollow(FOLLOW_deleteWhere_in_delete1782);
 6801  12
                     deleteWhere148=deleteWhere();
 6802  
 
 6803  12
                     state._fsp--;
 6804  
 
 6805  12
                     adaptor.addChild(root_0, deleteWhere148.getTree());
 6806  
 
 6807  
                     }
 6808  
                     break;
 6809  
 
 6810  
             }
 6811  
 
 6812  
 
 6813  
             }
 6814  
 
 6815  24
             retval.stop = input.LT(-1);
 6816  
 
 6817  
 
 6818  24
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6819  24
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6820  
 
 6821  
         }
 6822  0
         catch (RecognitionException re) {
 6823  0
             reportError(re);
 6824  0
             recover(input,re);
 6825  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6826  
 
 6827  
         }
 6828  
 
 6829  0
         finally {
 6830  
                 // do for sure before leaving
 6831  24
         }
 6832  24
         return retval;
 6833  
     }
 6834  
     // $ANTLR end "delete"
 6835  
 
 6836  
 
 6837  12
     public static class deleteData_return extends ParserRuleReturnScope {
 6838  
         Object tree;
 6839  12
         public Object getTree() { return tree; }
 6840  
     };
 6841  
 
 6842  
 
 6843  
     // $ANTLR start "deleteData"
 6844  
     // com\\googlecode\\sparkleg\\Sparql.g:228:1: deleteData : DATA quadPattern -> ^( DELETE DATA quadPattern ) ;
 6845  
     public final SparqlParser.deleteData_return deleteData() throws RecognitionException {
 6846  12
         SparqlParser.deleteData_return retval = new SparqlParser.deleteData_return();
 6847  12
         retval.start = input.LT(1);
 6848  
 
 6849  
 
 6850  12
         Object root_0 = null;
 6851  
 
 6852  12
         Token DATA149=null;
 6853  12
         SparqlParser.quadPattern_return quadPattern150 =null;
 6854  
 
 6855  
 
 6856  12
         Object DATA149_tree=null;
 6857  12
         RewriteRuleTokenStream stream_DATA=new RewriteRuleTokenStream(adaptor,"token DATA");
 6858  12
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6859  
         try {
 6860  
             // com\\googlecode\\sparkleg\\Sparql.g:229:5: ( DATA quadPattern -> ^( DELETE DATA quadPattern ) )
 6861  
             // com\\googlecode\\sparkleg\\Sparql.g:229:7: DATA quadPattern
 6862  
             {
 6863  12
             DATA149=(Token)match(input,DATA,FOLLOW_DATA_in_deleteData1800);  
 6864  12
             stream_DATA.add(DATA149);
 6865  
 
 6866  
 
 6867  12
             pushFollow(FOLLOW_quadPattern_in_deleteData1802);
 6868  12
             quadPattern150=quadPattern();
 6869  
 
 6870  12
             state._fsp--;
 6871  
 
 6872  12
             stream_quadPattern.add(quadPattern150.getTree());
 6873  
 
 6874  
             // AST REWRITE
 6875  
             // elements: quadPattern, DATA
 6876  
             // token labels: 
 6877  
             // rule labels: retval
 6878  
             // token list labels: 
 6879  
             // rule list labels: 
 6880  
             // wildcard labels: 
 6881  12
             retval.tree = root_0;
 6882  12
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6883  
 
 6884  12
             root_0 = (Object)adaptor.nil();
 6885  
             // 229:24: -> ^( DELETE DATA quadPattern )
 6886  
             {
 6887  
                 // com\\googlecode\\sparkleg\\Sparql.g:229:27: ^( DELETE DATA quadPattern )
 6888  
                 {
 6889  12
                 Object root_1 = (Object)adaptor.nil();
 6890  12
                 root_1 = (Object)adaptor.becomeRoot(
 6891  
                 (Object)adaptor.create(DELETE, "DELETE")
 6892  
                 , root_1);
 6893  
 
 6894  12
                 adaptor.addChild(root_1, 
 6895  
                 stream_DATA.nextNode()
 6896  
                 );
 6897  
 
 6898  12
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 6899  
 
 6900  12
                 adaptor.addChild(root_0, root_1);
 6901  
                 }
 6902  
 
 6903  
             }
 6904  
 
 6905  
 
 6906  12
             retval.tree = root_0;
 6907  
 
 6908  
             }
 6909  
 
 6910  12
             retval.stop = input.LT(-1);
 6911  
 
 6912  
 
 6913  12
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6914  12
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6915  
 
 6916  
         }
 6917  0
         catch (RecognitionException re) {
 6918  0
             reportError(re);
 6919  0
             recover(input,re);
 6920  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6921  
 
 6922  
         }
 6923  
 
 6924  0
         finally {
 6925  
                 // do for sure before leaving
 6926  12
         }
 6927  12
         return retval;
 6928  
     }
 6929  
     // $ANTLR end "deleteData"
 6930  
 
 6931  
 
 6932  12
     public static class deleteWhere_return extends ParserRuleReturnScope {
 6933  
         Object tree;
 6934  12
         public Object getTree() { return tree; }
 6935  
     };
 6936  
 
 6937  
 
 6938  
     // $ANTLR start "deleteWhere"
 6939  
     // com\\googlecode\\sparkleg\\Sparql.g:232:1: deleteWhere : WHERE quadPattern -> ^( DELETE WHERE quadPattern ) ;
 6940  
     public final SparqlParser.deleteWhere_return deleteWhere() throws RecognitionException {
 6941  12
         SparqlParser.deleteWhere_return retval = new SparqlParser.deleteWhere_return();
 6942  12
         retval.start = input.LT(1);
 6943  
 
 6944  
 
 6945  12
         Object root_0 = null;
 6946  
 
 6947  12
         Token WHERE151=null;
 6948  12
         SparqlParser.quadPattern_return quadPattern152 =null;
 6949  
 
 6950  
 
 6951  12
         Object WHERE151_tree=null;
 6952  12
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 6953  12
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6954  
         try {
 6955  
             // com\\googlecode\\sparkleg\\Sparql.g:233:5: ( WHERE quadPattern -> ^( DELETE WHERE quadPattern ) )
 6956  
             // com\\googlecode\\sparkleg\\Sparql.g:233:7: WHERE quadPattern
 6957  
             {
 6958  12
             WHERE151=(Token)match(input,WHERE,FOLLOW_WHERE_in_deleteWhere1829);  
 6959  12
             stream_WHERE.add(WHERE151);
 6960  
 
 6961  
 
 6962  12
             pushFollow(FOLLOW_quadPattern_in_deleteWhere1831);
 6963  12
             quadPattern152=quadPattern();
 6964  
 
 6965  12
             state._fsp--;
 6966  
 
 6967  12
             stream_quadPattern.add(quadPattern152.getTree());
 6968  
 
 6969  
             // AST REWRITE
 6970  
             // elements: WHERE, quadPattern
 6971  
             // token labels: 
 6972  
             // rule labels: retval
 6973  
             // token list labels: 
 6974  
             // rule list labels: 
 6975  
             // wildcard labels: 
 6976  12
             retval.tree = root_0;
 6977  12
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6978  
 
 6979  12
             root_0 = (Object)adaptor.nil();
 6980  
             // 233:25: -> ^( DELETE WHERE quadPattern )
 6981  
             {
 6982  
                 // com\\googlecode\\sparkleg\\Sparql.g:233:28: ^( DELETE WHERE quadPattern )
 6983  
                 {
 6984  12
                 Object root_1 = (Object)adaptor.nil();
 6985  12
                 root_1 = (Object)adaptor.becomeRoot(
 6986  
                 (Object)adaptor.create(DELETE, "DELETE")
 6987  
                 , root_1);
 6988  
 
 6989  12
                 adaptor.addChild(root_1, 
 6990  
                 stream_WHERE.nextNode()
 6991  
                 );
 6992  
 
 6993  12
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 6994  
 
 6995  12
                 adaptor.addChild(root_0, root_1);
 6996  
                 }
 6997  
 
 6998  
             }
 6999  
 
 7000  
 
 7001  12
             retval.tree = root_0;
 7002  
 
 7003  
             }
 7004  
 
 7005  12
             retval.stop = input.LT(-1);
 7006  
 
 7007  
 
 7008  12
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7009  12
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7010  
 
 7011  
         }
 7012  0
         catch (RecognitionException re) {
 7013  0
             reportError(re);
 7014  0
             recover(input,re);
 7015  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7016  
 
 7017  
         }
 7018  
 
 7019  0
         finally {
 7020  
                 // do for sure before leaving
 7021  12
         }
 7022  12
         return retval;
 7023  
     }
 7024  
     // $ANTLR end "deleteWhere"
 7025  
 
 7026  
 
 7027  80
     public static class modify_return extends ParserRuleReturnScope {
 7028  
         Object tree;
 7029  80
         public Object getTree() { return tree; }
 7030  
     };
 7031  
 
 7032  
 
 7033  
     // $ANTLR start "modify"
 7034  
     // com\\googlecode\\sparkleg\\Sparql.g:236:1: modify : ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern -> ^( MODIFY ( ^( WITH iriRef ) )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) ) ;
 7035  
     public final SparqlParser.modify_return modify() throws RecognitionException {
 7036  80
         SparqlParser.modify_return retval = new SparqlParser.modify_return();
 7037  80
         retval.start = input.LT(1);
 7038  
 
 7039  
 
 7040  80
         Object root_0 = null;
 7041  
 
 7042  80
         Token WITH153=null;
 7043  80
         Token WHERE159=null;
 7044  80
         SparqlParser.iriRef_return iriRef154 =null;
 7045  
 
 7046  80
         SparqlParser.deleteClause_return deleteClause155 =null;
 7047  
 
 7048  80
         SparqlParser.insertClause_return insertClause156 =null;
 7049  
 
 7050  80
         SparqlParser.insertClause_return insertClause157 =null;
 7051  
 
 7052  80
         SparqlParser.usingClause_return usingClause158 =null;
 7053  
 
 7054  80
         SparqlParser.groupGraphPattern_return groupGraphPattern160 =null;
 7055  
 
 7056  
 
 7057  80
         Object WITH153_tree=null;
 7058  80
         Object WHERE159_tree=null;
 7059  80
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 7060  80
         RewriteRuleTokenStream stream_WITH=new RewriteRuleTokenStream(adaptor,"token WITH");
 7061  80
         RewriteRuleSubtreeStream stream_deleteClause=new RewriteRuleSubtreeStream(adaptor,"rule deleteClause");
 7062  80
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 7063  80
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 7064  80
         RewriteRuleSubtreeStream stream_insertClause=new RewriteRuleSubtreeStream(adaptor,"rule insertClause");
 7065  80
         RewriteRuleSubtreeStream stream_usingClause=new RewriteRuleSubtreeStream(adaptor,"rule usingClause");
 7066  
         try {
 7067  
             // com\\googlecode\\sparkleg\\Sparql.g:237:5: ( ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern -> ^( MODIFY ( ^( WITH iriRef ) )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) ) )
 7068  
             // com\\googlecode\\sparkleg\\Sparql.g:237:7: ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern
 7069  
             {
 7070  
             // com\\googlecode\\sparkleg\\Sparql.g:237:7: ( WITH iriRef )?
 7071  80
             int alt50=2;
 7072  80
             switch ( input.LA(1) ) {
 7073  
                 case WITH:
 7074  
                     {
 7075  14
                     alt50=1;
 7076  
                     }
 7077  
                     break;
 7078  
             }
 7079  
 
 7080  80
             switch (alt50) {
 7081  
                 case 1 :
 7082  
                     // com\\googlecode\\sparkleg\\Sparql.g:237:8: WITH iriRef
 7083  
                     {
 7084  14
                     WITH153=(Token)match(input,WITH,FOLLOW_WITH_in_modify1863);  
 7085  14
                     stream_WITH.add(WITH153);
 7086  
 
 7087  
 
 7088  14
                     pushFollow(FOLLOW_iriRef_in_modify1865);
 7089  14
                     iriRef154=iriRef();
 7090  
 
 7091  14
                     state._fsp--;
 7092  
 
 7093  14
                     stream_iriRef.add(iriRef154.getTree());
 7094  
 
 7095  
                     }
 7096  
                     break;
 7097  
 
 7098  
             }
 7099  
 
 7100  
 
 7101  
             // com\\googlecode\\sparkleg\\Sparql.g:237:22: ( deleteClause ( insertClause )? | insertClause )
 7102  80
             int alt52=2;
 7103  80
             switch ( input.LA(1) ) {
 7104  
             case DELETE:
 7105  
                 {
 7106  66
                 alt52=1;
 7107  
                 }
 7108  66
                 break;
 7109  
             case INSERT:
 7110  
                 {
 7111  14
                 alt52=2;
 7112  
                 }
 7113  14
                 break;
 7114  
             default:
 7115  0
                 NoViableAltException nvae =
 7116  
                     new NoViableAltException("", 52, 0, input);
 7117  
 
 7118  0
                 throw nvae;
 7119  
 
 7120  
             }
 7121  
 
 7122  80
             switch (alt52) {
 7123  
                 case 1 :
 7124  
                     // com\\googlecode\\sparkleg\\Sparql.g:237:23: deleteClause ( insertClause )?
 7125  
                     {
 7126  66
                     pushFollow(FOLLOW_deleteClause_in_modify1870);
 7127  66
                     deleteClause155=deleteClause();
 7128  
 
 7129  66
                     state._fsp--;
 7130  
 
 7131  66
                     stream_deleteClause.add(deleteClause155.getTree());
 7132  
 
 7133  
                     // com\\googlecode\\sparkleg\\Sparql.g:237:36: ( insertClause )?
 7134  66
                     int alt51=2;
 7135  66
                     switch ( input.LA(1) ) {
 7136  
                         case INSERT:
 7137  
                             {
 7138  10
                             alt51=1;
 7139  
                             }
 7140  
                             break;
 7141  
                     }
 7142  
 
 7143  66
                     switch (alt51) {
 7144  
                         case 1 :
 7145  
                             // com\\googlecode\\sparkleg\\Sparql.g:237:36: insertClause
 7146  
                             {
 7147  10
                             pushFollow(FOLLOW_insertClause_in_modify1872);
 7148  10
                             insertClause156=insertClause();
 7149  
 
 7150  10
                             state._fsp--;
 7151  
 
 7152  10
                             stream_insertClause.add(insertClause156.getTree());
 7153  
 
 7154  
                             }
 7155  
                             break;
 7156  
 
 7157  
                     }
 7158  
 
 7159  
 
 7160  
                     }
 7161  66
                     break;
 7162  
                 case 2 :
 7163  
                     // com\\googlecode\\sparkleg\\Sparql.g:237:52: insertClause
 7164  
                     {
 7165  14
                     pushFollow(FOLLOW_insertClause_in_modify1877);
 7166  14
                     insertClause157=insertClause();
 7167  
 
 7168  14
                     state._fsp--;
 7169  
 
 7170  14
                     stream_insertClause.add(insertClause157.getTree());
 7171  
 
 7172  
                     }
 7173  
                     break;
 7174  
 
 7175  
             }
 7176  
 
 7177  
 
 7178  
             // com\\googlecode\\sparkleg\\Sparql.g:237:66: ( usingClause )*
 7179  
             loop53:
 7180  
             do {
 7181  98
                 int alt53=2;
 7182  98
                 switch ( input.LA(1) ) {
 7183  
                 case USING:
 7184  
                     {
 7185  18
                     alt53=1;
 7186  
                     }
 7187  
                     break;
 7188  
 
 7189  
                 }
 7190  
 
 7191  98
                 switch (alt53) {
 7192  
                     case 1 :
 7193  
                         // com\\googlecode\\sparkleg\\Sparql.g:237:66: usingClause
 7194  
                         {
 7195  18
                         pushFollow(FOLLOW_usingClause_in_modify1880);
 7196  18
                         usingClause158=usingClause();
 7197  
 
 7198  18
                         state._fsp--;
 7199  
 
 7200  18
                         stream_usingClause.add(usingClause158.getTree());
 7201  
 
 7202  
                         }
 7203  18
                         break;
 7204  
 
 7205  
                     default :
 7206  80
                         break loop53;
 7207  
                 }
 7208  18
             } while (true);
 7209  
 
 7210  
 
 7211  80
             WHERE159=(Token)match(input,WHERE,FOLLOW_WHERE_in_modify1883);  
 7212  80
             stream_WHERE.add(WHERE159);
 7213  
 
 7214  
 
 7215  80
             pushFollow(FOLLOW_groupGraphPattern_in_modify1885);
 7216  80
             groupGraphPattern160=groupGraphPattern();
 7217  
 
 7218  80
             state._fsp--;
 7219  
 
 7220  80
             stream_groupGraphPattern.add(groupGraphPattern160.getTree());
 7221  
 
 7222  
             // AST REWRITE
 7223  
             // elements: usingClause, iriRef, WITH, groupGraphPattern, insertClause, deleteClause
 7224  
             // token labels: 
 7225  
             // rule labels: retval
 7226  
             // token list labels: 
 7227  
             // rule list labels: 
 7228  
             // wildcard labels: 
 7229  80
             retval.tree = root_0;
 7230  80
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7231  
 
 7232  80
             root_0 = (Object)adaptor.nil();
 7233  
             // 237:103: -> ^( MODIFY ( ^( WITH iriRef ) )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) )
 7234  
             {
 7235  
                 // com\\googlecode\\sparkleg\\Sparql.g:237:106: ^( MODIFY ( ^( WITH iriRef ) )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) )
 7236  
                 {
 7237  80
                 Object root_1 = (Object)adaptor.nil();
 7238  80
                 root_1 = (Object)adaptor.becomeRoot(
 7239  
                 (Object)adaptor.create(MODIFY, "MODIFY")
 7240  
                 , root_1);
 7241  
 
 7242  
                 // com\\googlecode\\sparkleg\\Sparql.g:237:115: ( ^( WITH iriRef ) )?
 7243  80
                 if ( stream_iriRef.hasNext()||stream_WITH.hasNext() ) {
 7244  
                     // com\\googlecode\\sparkleg\\Sparql.g:237:115: ^( WITH iriRef )
 7245  
                     {
 7246  14
                     Object root_2 = (Object)adaptor.nil();
 7247  14
                     root_2 = (Object)adaptor.becomeRoot(
 7248  
                     stream_WITH.nextNode()
 7249  
                     , root_2);
 7250  
 
 7251  14
                     adaptor.addChild(root_2, stream_iriRef.nextTree());
 7252  
 
 7253  14
                     adaptor.addChild(root_1, root_2);
 7254  
                     }
 7255  
 
 7256  
                 }
 7257  80
                 stream_iriRef.reset();
 7258  80
                 stream_WITH.reset();
 7259  
 
 7260  
                 // com\\googlecode\\sparkleg\\Sparql.g:237:131: ( deleteClause )*
 7261  146
                 while ( stream_deleteClause.hasNext() ) {
 7262  66
                     adaptor.addChild(root_1, stream_deleteClause.nextTree());
 7263  
 
 7264  
                 }
 7265  80
                 stream_deleteClause.reset();
 7266  
 
 7267  
                 // com\\googlecode\\sparkleg\\Sparql.g:237:145: ( insertClause )*
 7268  104
                 while ( stream_insertClause.hasNext() ) {
 7269  24
                     adaptor.addChild(root_1, stream_insertClause.nextTree());
 7270  
 
 7271  
                 }
 7272  80
                 stream_insertClause.reset();
 7273  
 
 7274  
                 // com\\googlecode\\sparkleg\\Sparql.g:237:159: ( usingClause )*
 7275  98
                 while ( stream_usingClause.hasNext() ) {
 7276  18
                     adaptor.addChild(root_1, stream_usingClause.nextTree());
 7277  
 
 7278  
                 }
 7279  80
                 stream_usingClause.reset();
 7280  
 
 7281  
                 // com\\googlecode\\sparkleg\\Sparql.g:237:172: ^( WHERE_CLAUSE groupGraphPattern )
 7282  
                 {
 7283  80
                 Object root_2 = (Object)adaptor.nil();
 7284  80
                 root_2 = (Object)adaptor.becomeRoot(
 7285  
                 (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 7286  
                 , root_2);
 7287  
 
 7288  80
                 adaptor.addChild(root_2, stream_groupGraphPattern.nextTree());
 7289  
 
 7290  80
                 adaptor.addChild(root_1, root_2);
 7291  
                 }
 7292  
 
 7293  80
                 adaptor.addChild(root_0, root_1);
 7294  
                 }
 7295  
 
 7296  
             }
 7297  
 
 7298  
 
 7299  80
             retval.tree = root_0;
 7300  
 
 7301  
             }
 7302  
 
 7303  80
             retval.stop = input.LT(-1);
 7304  
 
 7305  
 
 7306  80
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7307  80
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7308  
 
 7309  
         }
 7310  0
         catch (RecognitionException re) {
 7311  0
             reportError(re);
 7312  0
             recover(input,re);
 7313  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7314  
 
 7315  
         }
 7316  
 
 7317  0
         finally {
 7318  
                 // do for sure before leaving
 7319  80
         }
 7320  80
         return retval;
 7321  
     }
 7322  
     // $ANTLR end "modify"
 7323  
 
 7324  
 
 7325  66
     public static class deleteClause_return extends ParserRuleReturnScope {
 7326  
         Object tree;
 7327  66
         public Object getTree() { return tree; }
 7328  
     };
 7329  
 
 7330  
 
 7331  
     // $ANTLR start "deleteClause"
 7332  
     // com\\googlecode\\sparkleg\\Sparql.g:240:1: deleteClause : DELETE quadPattern -> DELETE quadPattern ;
 7333  
     public final SparqlParser.deleteClause_return deleteClause() throws RecognitionException {
 7334  66
         SparqlParser.deleteClause_return retval = new SparqlParser.deleteClause_return();
 7335  66
         retval.start = input.LT(1);
 7336  
 
 7337  
 
 7338  66
         Object root_0 = null;
 7339  
 
 7340  66
         Token DELETE161=null;
 7341  66
         SparqlParser.quadPattern_return quadPattern162 =null;
 7342  
 
 7343  
 
 7344  66
         Object DELETE161_tree=null;
 7345  66
         RewriteRuleTokenStream stream_DELETE=new RewriteRuleTokenStream(adaptor,"token DELETE");
 7346  66
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7347  
         try {
 7348  
             // com\\googlecode\\sparkleg\\Sparql.g:241:5: ( DELETE quadPattern -> DELETE quadPattern )
 7349  
             // com\\googlecode\\sparkleg\\Sparql.g:241:7: DELETE quadPattern
 7350  
             {
 7351  66
             DELETE161=(Token)match(input,DELETE,FOLLOW_DELETE_in_deleteClause1932);  
 7352  66
             stream_DELETE.add(DELETE161);
 7353  
 
 7354  
 
 7355  66
             pushFollow(FOLLOW_quadPattern_in_deleteClause1934);
 7356  66
             quadPattern162=quadPattern();
 7357  
 
 7358  66
             state._fsp--;
 7359  
 
 7360  66
             stream_quadPattern.add(quadPattern162.getTree());
 7361  
 
 7362  
             // AST REWRITE
 7363  
             // elements: DELETE, quadPattern
 7364  
             // token labels: 
 7365  
             // rule labels: retval
 7366  
             // token list labels: 
 7367  
             // rule list labels: 
 7368  
             // wildcard labels: 
 7369  66
             retval.tree = root_0;
 7370  66
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7371  
 
 7372  66
             root_0 = (Object)adaptor.nil();
 7373  
             // 241:26: -> DELETE quadPattern
 7374  
             {
 7375  66
                 adaptor.addChild(root_0, 
 7376  
                 stream_DELETE.nextNode()
 7377  
                 );
 7378  
 
 7379  66
                 adaptor.addChild(root_0, stream_quadPattern.nextTree());
 7380  
 
 7381  
             }
 7382  
 
 7383  
 
 7384  66
             retval.tree = root_0;
 7385  
 
 7386  
             }
 7387  
 
 7388  66
             retval.stop = input.LT(-1);
 7389  
 
 7390  
 
 7391  66
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7392  66
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7393  
 
 7394  
         }
 7395  0
         catch (RecognitionException re) {
 7396  0
             reportError(re);
 7397  0
             recover(input,re);
 7398  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7399  
 
 7400  
         }
 7401  
 
 7402  0
         finally {
 7403  
                 // do for sure before leaving
 7404  66
         }
 7405  66
         return retval;
 7406  
     }
 7407  
     // $ANTLR end "deleteClause"
 7408  
 
 7409  
 
 7410  24
     public static class insertClause_return extends ParserRuleReturnScope {
 7411  
         Object tree;
 7412  24
         public Object getTree() { return tree; }
 7413  
     };
 7414  
 
 7415  
 
 7416  
     // $ANTLR start "insertClause"
 7417  
     // com\\googlecode\\sparkleg\\Sparql.g:244:1: insertClause : INSERT quadPattern -> INSERT quadPattern ;
 7418  
     public final SparqlParser.insertClause_return insertClause() throws RecognitionException {
 7419  24
         SparqlParser.insertClause_return retval = new SparqlParser.insertClause_return();
 7420  24
         retval.start = input.LT(1);
 7421  
 
 7422  
 
 7423  24
         Object root_0 = null;
 7424  
 
 7425  24
         Token INSERT163=null;
 7426  24
         SparqlParser.quadPattern_return quadPattern164 =null;
 7427  
 
 7428  
 
 7429  24
         Object INSERT163_tree=null;
 7430  24
         RewriteRuleTokenStream stream_INSERT=new RewriteRuleTokenStream(adaptor,"token INSERT");
 7431  24
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7432  
         try {
 7433  
             // com\\googlecode\\sparkleg\\Sparql.g:245:5: ( INSERT quadPattern -> INSERT quadPattern )
 7434  
             // com\\googlecode\\sparkleg\\Sparql.g:245:7: INSERT quadPattern
 7435  
             {
 7436  24
             INSERT163=(Token)match(input,INSERT,FOLLOW_INSERT_in_insertClause1963);  
 7437  24
             stream_INSERT.add(INSERT163);
 7438  
 
 7439  
 
 7440  24
             pushFollow(FOLLOW_quadPattern_in_insertClause1965);
 7441  24
             quadPattern164=quadPattern();
 7442  
 
 7443  24
             state._fsp--;
 7444  
 
 7445  24
             stream_quadPattern.add(quadPattern164.getTree());
 7446  
 
 7447  
             // AST REWRITE
 7448  
             // elements: quadPattern, INSERT
 7449  
             // token labels: 
 7450  
             // rule labels: retval
 7451  
             // token list labels: 
 7452  
             // rule list labels: 
 7453  
             // wildcard labels: 
 7454  24
             retval.tree = root_0;
 7455  24
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7456  
 
 7457  24
             root_0 = (Object)adaptor.nil();
 7458  
             // 245:26: -> INSERT quadPattern
 7459  
             {
 7460  24
                 adaptor.addChild(root_0, 
 7461  
                 stream_INSERT.nextNode()
 7462  
                 );
 7463  
 
 7464  24
                 adaptor.addChild(root_0, stream_quadPattern.nextTree());
 7465  
 
 7466  
             }
 7467  
 
 7468  
 
 7469  24
             retval.tree = root_0;
 7470  
 
 7471  
             }
 7472  
 
 7473  24
             retval.stop = input.LT(-1);
 7474  
 
 7475  
 
 7476  24
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7477  24
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7478  
 
 7479  
         }
 7480  0
         catch (RecognitionException re) {
 7481  0
             reportError(re);
 7482  0
             recover(input,re);
 7483  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7484  
 
 7485  
         }
 7486  
 
 7487  0
         finally {
 7488  
                 // do for sure before leaving
 7489  24
         }
 7490  24
         return retval;
 7491  
     }
 7492  
     // $ANTLR end "insertClause"
 7493  
 
 7494  
 
 7495  18
     public static class usingClause_return extends ParserRuleReturnScope {
 7496  
         Object tree;
 7497  18
         public Object getTree() { return tree; }
 7498  
     };
 7499  
 
 7500  
 
 7501  
     // $ANTLR start "usingClause"
 7502  
     // com\\googlecode\\sparkleg\\Sparql.g:248:1: usingClause : USING ( NAMED )? iriRef -> ^( USING ( NAMED )? iriRef ) ;
 7503  
     public final SparqlParser.usingClause_return usingClause() throws RecognitionException {
 7504  18
         SparqlParser.usingClause_return retval = new SparqlParser.usingClause_return();
 7505  18
         retval.start = input.LT(1);
 7506  
 
 7507  
 
 7508  18
         Object root_0 = null;
 7509  
 
 7510  18
         Token USING165=null;
 7511  18
         Token NAMED166=null;
 7512  18
         SparqlParser.iriRef_return iriRef167 =null;
 7513  
 
 7514  
 
 7515  18
         Object USING165_tree=null;
 7516  18
         Object NAMED166_tree=null;
 7517  18
         RewriteRuleTokenStream stream_USING=new RewriteRuleTokenStream(adaptor,"token USING");
 7518  18
         RewriteRuleTokenStream stream_NAMED=new RewriteRuleTokenStream(adaptor,"token NAMED");
 7519  18
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 7520  
         try {
 7521  
             // com\\googlecode\\sparkleg\\Sparql.g:249:5: ( USING ( NAMED )? iriRef -> ^( USING ( NAMED )? iriRef ) )
 7522  
             // com\\googlecode\\sparkleg\\Sparql.g:249:7: USING ( NAMED )? iriRef
 7523  
             {
 7524  18
             USING165=(Token)match(input,USING,FOLLOW_USING_in_usingClause1988);  
 7525  18
             stream_USING.add(USING165);
 7526  
 
 7527  
 
 7528  
             // com\\googlecode\\sparkleg\\Sparql.g:249:13: ( NAMED )?
 7529  18
             int alt54=2;
 7530  18
             switch ( input.LA(1) ) {
 7531  
                 case NAMED:
 7532  
                     {
 7533  0
                     alt54=1;
 7534  
                     }
 7535  
                     break;
 7536  
             }
 7537  
 
 7538  18
             switch (alt54) {
 7539  
                 case 1 :
 7540  
                     // com\\googlecode\\sparkleg\\Sparql.g:249:13: NAMED
 7541  
                     {
 7542  0
                     NAMED166=(Token)match(input,NAMED,FOLLOW_NAMED_in_usingClause1990);  
 7543  0
                     stream_NAMED.add(NAMED166);
 7544  
 
 7545  
 
 7546  
                     }
 7547  
                     break;
 7548  
 
 7549  
             }
 7550  
 
 7551  
 
 7552  18
             pushFollow(FOLLOW_iriRef_in_usingClause1993);
 7553  18
             iriRef167=iriRef();
 7554  
 
 7555  18
             state._fsp--;
 7556  
 
 7557  18
             stream_iriRef.add(iriRef167.getTree());
 7558  
 
 7559  
             // AST REWRITE
 7560  
             // elements: USING, iriRef, NAMED
 7561  
             // token labels: 
 7562  
             // rule labels: retval
 7563  
             // token list labels: 
 7564  
             // rule list labels: 
 7565  
             // wildcard labels: 
 7566  18
             retval.tree = root_0;
 7567  18
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7568  
 
 7569  18
             root_0 = (Object)adaptor.nil();
 7570  
             // 249:27: -> ^( USING ( NAMED )? iriRef )
 7571  
             {
 7572  
                 // com\\googlecode\\sparkleg\\Sparql.g:249:30: ^( USING ( NAMED )? iriRef )
 7573  
                 {
 7574  18
                 Object root_1 = (Object)adaptor.nil();
 7575  18
                 root_1 = (Object)adaptor.becomeRoot(
 7576  
                 stream_USING.nextNode()
 7577  
                 , root_1);
 7578  
 
 7579  
                 // com\\googlecode\\sparkleg\\Sparql.g:249:38: ( NAMED )?
 7580  18
                 if ( stream_NAMED.hasNext() ) {
 7581  0
                     adaptor.addChild(root_1, 
 7582  
                     stream_NAMED.nextNode()
 7583  
                     );
 7584  
 
 7585  
                 }
 7586  18
                 stream_NAMED.reset();
 7587  
 
 7588  18
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 7589  
 
 7590  18
                 adaptor.addChild(root_0, root_1);
 7591  
                 }
 7592  
 
 7593  
             }
 7594  
 
 7595  
 
 7596  18
             retval.tree = root_0;
 7597  
 
 7598  
             }
 7599  
 
 7600  18
             retval.stop = input.LT(-1);
 7601  
 
 7602  
 
 7603  18
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7604  18
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7605  
 
 7606  
         }
 7607  0
         catch (RecognitionException re) {
 7608  0
             reportError(re);
 7609  0
             recover(input,re);
 7610  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7611  
 
 7612  
         }
 7613  
 
 7614  0
         finally {
 7615  
                 // do for sure before leaving
 7616  18
         }
 7617  18
         return retval;
 7618  
     }
 7619  
     // $ANTLR end "usingClause"
 7620  
 
 7621  
 
 7622  0
     public static class graphOrDefault_return extends ParserRuleReturnScope {
 7623  
         Object tree;
 7624  0
         public Object getTree() { return tree; }
 7625  
     };
 7626  
 
 7627  
 
 7628  
     // $ANTLR start "graphOrDefault"
 7629  
     // com\\googlecode\\sparkleg\\Sparql.g:252:1: graphOrDefault : ( DEFAULT | ( GRAPH )? iriRef );
 7630  
     public final SparqlParser.graphOrDefault_return graphOrDefault() throws RecognitionException {
 7631  0
         SparqlParser.graphOrDefault_return retval = new SparqlParser.graphOrDefault_return();
 7632  0
         retval.start = input.LT(1);
 7633  
 
 7634  
 
 7635  0
         Object root_0 = null;
 7636  
 
 7637  0
         Token DEFAULT168=null;
 7638  0
         Token GRAPH169=null;
 7639  0
         SparqlParser.iriRef_return iriRef170 =null;
 7640  
 
 7641  
 
 7642  0
         Object DEFAULT168_tree=null;
 7643  0
         Object GRAPH169_tree=null;
 7644  
 
 7645  
         try {
 7646  
             // com\\googlecode\\sparkleg\\Sparql.g:253:5: ( DEFAULT | ( GRAPH )? iriRef )
 7647  0
             int alt56=2;
 7648  0
             switch ( input.LA(1) ) {
 7649  
             case DEFAULT:
 7650  
                 {
 7651  0
                 alt56=1;
 7652  
                 }
 7653  0
                 break;
 7654  
             case GRAPH:
 7655  
             case IRI_REF:
 7656  
             case PNAME_LN:
 7657  
             case PNAME_NS:
 7658  
                 {
 7659  0
                 alt56=2;
 7660  
                 }
 7661  0
                 break;
 7662  
             default:
 7663  0
                 NoViableAltException nvae =
 7664  
                     new NoViableAltException("", 56, 0, input);
 7665  
 
 7666  0
                 throw nvae;
 7667  
 
 7668  
             }
 7669  
 
 7670  0
             switch (alt56) {
 7671  
                 case 1 :
 7672  
                     // com\\googlecode\\sparkleg\\Sparql.g:253:7: DEFAULT
 7673  
                     {
 7674  0
                     root_0 = (Object)adaptor.nil();
 7675  
 
 7676  
 
 7677  0
                     DEFAULT168=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphOrDefault2024); 
 7678  0
                     DEFAULT168_tree = 
 7679  
                     (Object)adaptor.create(DEFAULT168)
 7680  
                     ;
 7681  0
                     adaptor.addChild(root_0, DEFAULT168_tree);
 7682  
 
 7683  
 
 7684  
                     }
 7685  0
                     break;
 7686  
                 case 2 :
 7687  
                     // com\\googlecode\\sparkleg\\Sparql.g:254:7: ( GRAPH )? iriRef
 7688  
                     {
 7689  0
                     root_0 = (Object)adaptor.nil();
 7690  
 
 7691  
 
 7692  
                     // com\\googlecode\\sparkleg\\Sparql.g:254:7: ( GRAPH )?
 7693  0
                     int alt55=2;
 7694  0
                     switch ( input.LA(1) ) {
 7695  
                         case GRAPH:
 7696  
                             {
 7697  0
                             alt55=1;
 7698  
                             }
 7699  
                             break;
 7700  
                     }
 7701  
 
 7702  0
                     switch (alt55) {
 7703  
                         case 1 :
 7704  
                             // com\\googlecode\\sparkleg\\Sparql.g:254:7: GRAPH
 7705  
                             {
 7706  0
                             GRAPH169=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphOrDefault2033); 
 7707  0
                             GRAPH169_tree = 
 7708  
                             (Object)adaptor.create(GRAPH169)
 7709  
                             ;
 7710  0
                             adaptor.addChild(root_0, GRAPH169_tree);
 7711  
 
 7712  
 
 7713  
                             }
 7714  
                             break;
 7715  
 
 7716  
                     }
 7717  
 
 7718  
 
 7719  0
                     pushFollow(FOLLOW_iriRef_in_graphOrDefault2036);
 7720  0
                     iriRef170=iriRef();
 7721  
 
 7722  0
                     state._fsp--;
 7723  
 
 7724  0
                     adaptor.addChild(root_0, iriRef170.getTree());
 7725  
 
 7726  
                     }
 7727  
                     break;
 7728  
 
 7729  
             }
 7730  0
             retval.stop = input.LT(-1);
 7731  
 
 7732  
 
 7733  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7734  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7735  
 
 7736  
         }
 7737  0
         catch (RecognitionException re) {
 7738  0
             reportError(re);
 7739  0
             recover(input,re);
 7740  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7741  
 
 7742  
         }
 7743  
 
 7744  0
         finally {
 7745  
                 // do for sure before leaving
 7746  0
         }
 7747  0
         return retval;
 7748  
     }
 7749  
     // $ANTLR end "graphOrDefault"
 7750  
 
 7751  
 
 7752  4
     public static class graphRef_return extends ParserRuleReturnScope {
 7753  
         Object tree;
 7754  4
         public Object getTree() { return tree; }
 7755  
     };
 7756  
 
 7757  
 
 7758  
     // $ANTLR start "graphRef"
 7759  
     // com\\googlecode\\sparkleg\\Sparql.g:257:1: graphRef : GRAPH iriRef ;
 7760  
     public final SparqlParser.graphRef_return graphRef() throws RecognitionException {
 7761  4
         SparqlParser.graphRef_return retval = new SparqlParser.graphRef_return();
 7762  4
         retval.start = input.LT(1);
 7763  
 
 7764  
 
 7765  4
         Object root_0 = null;
 7766  
 
 7767  4
         Token GRAPH171=null;
 7768  4
         SparqlParser.iriRef_return iriRef172 =null;
 7769  
 
 7770  
 
 7771  4
         Object GRAPH171_tree=null;
 7772  
 
 7773  
         try {
 7774  
             // com\\googlecode\\sparkleg\\Sparql.g:258:5: ( GRAPH iriRef )
 7775  
             // com\\googlecode\\sparkleg\\Sparql.g:258:7: GRAPH iriRef
 7776  
             {
 7777  4
             root_0 = (Object)adaptor.nil();
 7778  
 
 7779  
 
 7780  4
             GRAPH171=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphRef2063); 
 7781  4
             GRAPH171_tree = 
 7782  
             (Object)adaptor.create(GRAPH171)
 7783  
             ;
 7784  4
             adaptor.addChild(root_0, GRAPH171_tree);
 7785  
 
 7786  
 
 7787  4
             pushFollow(FOLLOW_iriRef_in_graphRef2065);
 7788  4
             iriRef172=iriRef();
 7789  
 
 7790  4
             state._fsp--;
 7791  
 
 7792  4
             adaptor.addChild(root_0, iriRef172.getTree());
 7793  
 
 7794  
             }
 7795  
 
 7796  4
             retval.stop = input.LT(-1);
 7797  
 
 7798  
 
 7799  4
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7800  4
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7801  
 
 7802  
         }
 7803  0
         catch (RecognitionException re) {
 7804  0
             reportError(re);
 7805  0
             recover(input,re);
 7806  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7807  
 
 7808  
         }
 7809  
 
 7810  0
         finally {
 7811  
                 // do for sure before leaving
 7812  4
         }
 7813  4
         return retval;
 7814  
     }
 7815  
     // $ANTLR end "graphRef"
 7816  
 
 7817  
 
 7818  16
     public static class graphRefAll_return extends ParserRuleReturnScope {
 7819  
         Object tree;
 7820  16
         public Object getTree() { return tree; }
 7821  
     };
 7822  
 
 7823  
 
 7824  
     // $ANTLR start "graphRefAll"
 7825  
     // com\\googlecode\\sparkleg\\Sparql.g:261:1: graphRefAll : ( graphRef | DEFAULT | NAMED | ALL );
 7826  
     public final SparqlParser.graphRefAll_return graphRefAll() throws RecognitionException {
 7827  16
         SparqlParser.graphRefAll_return retval = new SparqlParser.graphRefAll_return();
 7828  16
         retval.start = input.LT(1);
 7829  
 
 7830  
 
 7831  16
         Object root_0 = null;
 7832  
 
 7833  16
         Token DEFAULT174=null;
 7834  16
         Token NAMED175=null;
 7835  16
         Token ALL176=null;
 7836  16
         SparqlParser.graphRef_return graphRef173 =null;
 7837  
 
 7838  
 
 7839  16
         Object DEFAULT174_tree=null;
 7840  16
         Object NAMED175_tree=null;
 7841  16
         Object ALL176_tree=null;
 7842  
 
 7843  
         try {
 7844  
             // com\\googlecode\\sparkleg\\Sparql.g:262:5: ( graphRef | DEFAULT | NAMED | ALL )
 7845  16
             int alt57=4;
 7846  16
             switch ( input.LA(1) ) {
 7847  
             case GRAPH:
 7848  
                 {
 7849  4
                 alt57=1;
 7850  
                 }
 7851  4
                 break;
 7852  
             case DEFAULT:
 7853  
                 {
 7854  4
                 alt57=2;
 7855  
                 }
 7856  4
                 break;
 7857  
             case NAMED:
 7858  
                 {
 7859  4
                 alt57=3;
 7860  
                 }
 7861  4
                 break;
 7862  
             case ALL:
 7863  
                 {
 7864  4
                 alt57=4;
 7865  
                 }
 7866  4
                 break;
 7867  
             default:
 7868  0
                 NoViableAltException nvae =
 7869  
                     new NoViableAltException("", 57, 0, input);
 7870  
 
 7871  0
                 throw nvae;
 7872  
 
 7873  
             }
 7874  
 
 7875  16
             switch (alt57) {
 7876  
                 case 1 :
 7877  
                     // com\\googlecode\\sparkleg\\Sparql.g:262:7: graphRef
 7878  
                     {
 7879  4
                     root_0 = (Object)adaptor.nil();
 7880  
 
 7881  
 
 7882  4
                     pushFollow(FOLLOW_graphRef_in_graphRefAll2082);
 7883  4
                     graphRef173=graphRef();
 7884  
 
 7885  4
                     state._fsp--;
 7886  
 
 7887  4
                     adaptor.addChild(root_0, graphRef173.getTree());
 7888  
 
 7889  
                     }
 7890  4
                     break;
 7891  
                 case 2 :
 7892  
                     // com\\googlecode\\sparkleg\\Sparql.g:262:18: DEFAULT
 7893  
                     {
 7894  4
                     root_0 = (Object)adaptor.nil();
 7895  
 
 7896  
 
 7897  4
                     DEFAULT174=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphRefAll2086); 
 7898  4
                     DEFAULT174_tree = 
 7899  
                     (Object)adaptor.create(DEFAULT174)
 7900  
                     ;
 7901  4
                     adaptor.addChild(root_0, DEFAULT174_tree);
 7902  
 
 7903  
 
 7904  
                     }
 7905  4
                     break;
 7906  
                 case 3 :
 7907  
                     // com\\googlecode\\sparkleg\\Sparql.g:262:28: NAMED
 7908  
                     {
 7909  4
                     root_0 = (Object)adaptor.nil();
 7910  
 
 7911  
 
 7912  4
                     NAMED175=(Token)match(input,NAMED,FOLLOW_NAMED_in_graphRefAll2090); 
 7913  4
                     NAMED175_tree = 
 7914  
                     (Object)adaptor.create(NAMED175)
 7915  
                     ;
 7916  4
                     adaptor.addChild(root_0, NAMED175_tree);
 7917  
 
 7918  
 
 7919  
                     }
 7920  4
                     break;
 7921  
                 case 4 :
 7922  
                     // com\\googlecode\\sparkleg\\Sparql.g:262:36: ALL
 7923  
                     {
 7924  4
                     root_0 = (Object)adaptor.nil();
 7925  
 
 7926  
 
 7927  4
                     ALL176=(Token)match(input,ALL,FOLLOW_ALL_in_graphRefAll2094); 
 7928  4
                     ALL176_tree = 
 7929  
                     (Object)adaptor.create(ALL176)
 7930  
                     ;
 7931  4
                     adaptor.addChild(root_0, ALL176_tree);
 7932  
 
 7933  
 
 7934  
                     }
 7935  
                     break;
 7936  
 
 7937  
             }
 7938  16
             retval.stop = input.LT(-1);
 7939  
 
 7940  
 
 7941  16
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7942  16
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7943  
 
 7944  
         }
 7945  0
         catch (RecognitionException re) {
 7946  0
             reportError(re);
 7947  0
             recover(input,re);
 7948  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7949  
 
 7950  
         }
 7951  
 
 7952  0
         finally {
 7953  
                 // do for sure before leaving
 7954  16
         }
 7955  16
         return retval;
 7956  
     }
 7957  
     // $ANTLR end "graphRefAll"
 7958  
 
 7959  
 
 7960  122
     public static class quadPattern_return extends ParserRuleReturnScope {
 7961  
         Object tree;
 7962  122
         public Object getTree() { return tree; }
 7963  
     };
 7964  
 
 7965  
 
 7966  
     // $ANTLR start "quadPattern"
 7967  
     // com\\googlecode\\sparkleg\\Sparql.g:265:1: quadPattern : OPEN_CURLY_BRACE quads CLOSE_CURLY_BRACE -> quads ;
 7968  
     public final SparqlParser.quadPattern_return quadPattern() throws RecognitionException {
 7969  122
         SparqlParser.quadPattern_return retval = new SparqlParser.quadPattern_return();
 7970  122
         retval.start = input.LT(1);
 7971  
 
 7972  
 
 7973  122
         Object root_0 = null;
 7974  
 
 7975  122
         Token OPEN_CURLY_BRACE177=null;
 7976  122
         Token CLOSE_CURLY_BRACE179=null;
 7977  122
         SparqlParser.quads_return quads178 =null;
 7978  
 
 7979  
 
 7980  122
         Object OPEN_CURLY_BRACE177_tree=null;
 7981  122
         Object CLOSE_CURLY_BRACE179_tree=null;
 7982  122
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 7983  122
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 7984  122
         RewriteRuleSubtreeStream stream_quads=new RewriteRuleSubtreeStream(adaptor,"rule quads");
 7985  
         try {
 7986  
             // com\\googlecode\\sparkleg\\Sparql.g:266:5: ( OPEN_CURLY_BRACE quads CLOSE_CURLY_BRACE -> quads )
 7987  
             // com\\googlecode\\sparkleg\\Sparql.g:266:7: OPEN_CURLY_BRACE quads CLOSE_CURLY_BRACE
 7988  
             {
 7989  122
             OPEN_CURLY_BRACE177=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_quadPattern2111);  
 7990  122
             stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE177);
 7991  
 
 7992  
 
 7993  122
             pushFollow(FOLLOW_quads_in_quadPattern2113);
 7994  122
             quads178=quads();
 7995  
 
 7996  122
             state._fsp--;
 7997  
 
 7998  122
             stream_quads.add(quads178.getTree());
 7999  
 
 8000  122
             CLOSE_CURLY_BRACE179=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_quadPattern2115);  
 8001  122
             stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE179);
 8002  
 
 8003  
 
 8004  
             // AST REWRITE
 8005  
             // elements: quads
 8006  
             // token labels: 
 8007  
             // rule labels: retval
 8008  
             // token list labels: 
 8009  
             // rule list labels: 
 8010  
             // wildcard labels: 
 8011  122
             retval.tree = root_0;
 8012  122
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8013  
 
 8014  122
             root_0 = (Object)adaptor.nil();
 8015  
             // 266:48: -> quads
 8016  
             {
 8017  122
                 adaptor.addChild(root_0, stream_quads.nextTree());
 8018  
 
 8019  
             }
 8020  
 
 8021  
 
 8022  122
             retval.tree = root_0;
 8023  
 
 8024  
             }
 8025  
 
 8026  122
             retval.stop = input.LT(-1);
 8027  
 
 8028  
 
 8029  122
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8030  122
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8031  
 
 8032  
         }
 8033  0
         catch (RecognitionException re) {
 8034  0
             reportError(re);
 8035  0
             recover(input,re);
 8036  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8037  
 
 8038  
         }
 8039  
 
 8040  0
         finally {
 8041  
                 // do for sure before leaving
 8042  122
         }
 8043  122
         return retval;
 8044  
     }
 8045  
     // $ANTLR end "quadPattern"
 8046  
 
 8047  
 
 8048  122
     public static class quads_return extends ParserRuleReturnScope {
 8049  
         Object tree;
 8050  122
         public Object getTree() { return tree; }
 8051  
     };
 8052  
 
 8053  
 
 8054  
     // $ANTLR start "quads"
 8055  
     // com\\googlecode\\sparkleg\\Sparql.g:269:1: quads : ( triplesTemplate )? ( quadsNotTriples ( DOT )? ( triplesTemplate )? )* -> ( triplesTemplate )? ( quadsNotTriples ( triplesTemplate )? )* ;
 8056  
     public final SparqlParser.quads_return quads() throws RecognitionException {
 8057  122
         SparqlParser.quads_return retval = new SparqlParser.quads_return();
 8058  122
         retval.start = input.LT(1);
 8059  
 
 8060  
 
 8061  122
         Object root_0 = null;
 8062  
 
 8063  122
         Token DOT182=null;
 8064  122
         SparqlParser.triplesTemplate_return triplesTemplate180 =null;
 8065  
 
 8066  122
         SparqlParser.quadsNotTriples_return quadsNotTriples181 =null;
 8067  
 
 8068  122
         SparqlParser.triplesTemplate_return triplesTemplate183 =null;
 8069  
 
 8070  
 
 8071  122
         Object DOT182_tree=null;
 8072  122
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 8073  122
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8074  122
         RewriteRuleSubtreeStream stream_quadsNotTriples=new RewriteRuleSubtreeStream(adaptor,"rule quadsNotTriples");
 8075  
         try {
 8076  
             // com\\googlecode\\sparkleg\\Sparql.g:270:5: ( ( triplesTemplate )? ( quadsNotTriples ( DOT )? ( triplesTemplate )? )* -> ( triplesTemplate )? ( quadsNotTriples ( triplesTemplate )? )* )
 8077  
             // com\\googlecode\\sparkleg\\Sparql.g:270:7: ( triplesTemplate )? ( quadsNotTriples ( DOT )? ( triplesTemplate )? )*
 8078  
             {
 8079  
             // com\\googlecode\\sparkleg\\Sparql.g:270:7: ( triplesTemplate )?
 8080  122
             int alt58=2;
 8081  122
             switch ( input.LA(1) ) {
 8082  
                 case BLANK_NODE_LABEL:
 8083  
                 case DECIMAL:
 8084  
                 case DECIMAL_NEGATIVE:
 8085  
                 case DECIMAL_POSITIVE:
 8086  
                 case DOUBLE:
 8087  
                 case DOUBLE_NEGATIVE:
 8088  
                 case DOUBLE_POSITIVE:
 8089  
                 case FALSE:
 8090  
                 case INTEGER:
 8091  
                 case INTEGER_NEGATIVE:
 8092  
                 case INTEGER_POSITIVE:
 8093  
                 case IRI_REF:
 8094  
                 case OPEN_BRACE:
 8095  
                 case OPEN_SQUARE_BRACKET:
 8096  
                 case PNAME_LN:
 8097  
                 case PNAME_NS:
 8098  
                 case STRING_LITERAL1:
 8099  
                 case STRING_LITERAL2:
 8100  
                 case STRING_LITERAL_LONG1:
 8101  
                 case STRING_LITERAL_LONG2:
 8102  
                 case TRUE:
 8103  
                 case VAR1:
 8104  
                 case VAR2:
 8105  
                     {
 8106  88
                     alt58=1;
 8107  
                     }
 8108  
                     break;
 8109  
             }
 8110  
 
 8111  122
             switch (alt58) {
 8112  
                 case 1 :
 8113  
                     // com\\googlecode\\sparkleg\\Sparql.g:270:7: triplesTemplate
 8114  
                     {
 8115  88
                     pushFollow(FOLLOW_triplesTemplate_in_quads2140);
 8116  88
                     triplesTemplate180=triplesTemplate();
 8117  
 
 8118  88
                     state._fsp--;
 8119  
 
 8120  88
                     stream_triplesTemplate.add(triplesTemplate180.getTree());
 8121  
 
 8122  
                     }
 8123  
                     break;
 8124  
 
 8125  
             }
 8126  
 
 8127  
 
 8128  
             // com\\googlecode\\sparkleg\\Sparql.g:270:24: ( quadsNotTriples ( DOT )? ( triplesTemplate )? )*
 8129  
             loop61:
 8130  
             do {
 8131  156
                 int alt61=2;
 8132  156
                 switch ( input.LA(1) ) {
 8133  
                 case GRAPH:
 8134  
                     {
 8135  34
                     alt61=1;
 8136  
                     }
 8137  
                     break;
 8138  
 
 8139  
                 }
 8140  
 
 8141  156
                 switch (alt61) {
 8142  
                     case 1 :
 8143  
                         // com\\googlecode\\sparkleg\\Sparql.g:270:25: quadsNotTriples ( DOT )? ( triplesTemplate )?
 8144  
                         {
 8145  34
                         pushFollow(FOLLOW_quadsNotTriples_in_quads2144);
 8146  34
                         quadsNotTriples181=quadsNotTriples();
 8147  
 
 8148  34
                         state._fsp--;
 8149  
 
 8150  34
                         stream_quadsNotTriples.add(quadsNotTriples181.getTree());
 8151  
 
 8152  
                         // com\\googlecode\\sparkleg\\Sparql.g:270:41: ( DOT )?
 8153  34
                         int alt59=2;
 8154  34
                         switch ( input.LA(1) ) {
 8155  
                             case DOT:
 8156  
                                 {
 8157  0
                                 alt59=1;
 8158  
                                 }
 8159  
                                 break;
 8160  
                         }
 8161  
 
 8162  34
                         switch (alt59) {
 8163  
                             case 1 :
 8164  
                                 // com\\googlecode\\sparkleg\\Sparql.g:270:41: DOT
 8165  
                                 {
 8166  0
                                 DOT182=(Token)match(input,DOT,FOLLOW_DOT_in_quads2146);  
 8167  0
                                 stream_DOT.add(DOT182);
 8168  
 
 8169  
 
 8170  
                                 }
 8171  
                                 break;
 8172  
 
 8173  
                         }
 8174  
 
 8175  
 
 8176  
                         // com\\googlecode\\sparkleg\\Sparql.g:270:46: ( triplesTemplate )?
 8177  34
                         int alt60=2;
 8178  34
                         switch ( input.LA(1) ) {
 8179  
                             case BLANK_NODE_LABEL:
 8180  
                             case DECIMAL:
 8181  
                             case DECIMAL_NEGATIVE:
 8182  
                             case DECIMAL_POSITIVE:
 8183  
                             case DOUBLE:
 8184  
                             case DOUBLE_NEGATIVE:
 8185  
                             case DOUBLE_POSITIVE:
 8186  
                             case FALSE:
 8187  
                             case INTEGER:
 8188  
                             case INTEGER_NEGATIVE:
 8189  
                             case INTEGER_POSITIVE:
 8190  
                             case IRI_REF:
 8191  
                             case OPEN_BRACE:
 8192  
                             case OPEN_SQUARE_BRACKET:
 8193  
                             case PNAME_LN:
 8194  
                             case PNAME_NS:
 8195  
                             case STRING_LITERAL1:
 8196  
                             case STRING_LITERAL2:
 8197  
                             case STRING_LITERAL_LONG1:
 8198  
                             case STRING_LITERAL_LONG2:
 8199  
                             case TRUE:
 8200  
                             case VAR1:
 8201  
                             case VAR2:
 8202  
                                 {
 8203  0
                                 alt60=1;
 8204  
                                 }
 8205  
                                 break;
 8206  
                         }
 8207  
 
 8208  34
                         switch (alt60) {
 8209  
                             case 1 :
 8210  
                                 // com\\googlecode\\sparkleg\\Sparql.g:270:46: triplesTemplate
 8211  
                                 {
 8212  0
                                 pushFollow(FOLLOW_triplesTemplate_in_quads2149);
 8213  0
                                 triplesTemplate183=triplesTemplate();
 8214  
 
 8215  0
                                 state._fsp--;
 8216  
 
 8217  0
                                 stream_triplesTemplate.add(triplesTemplate183.getTree());
 8218  
 
 8219  
                                 }
 8220  
                                 break;
 8221  
 
 8222  
                         }
 8223  
 
 8224  
 
 8225  
                         }
 8226  34
                         break;
 8227  
 
 8228  
                     default :
 8229  122
                         break loop61;
 8230  
                 }
 8231  34
             } while (true);
 8232  
 
 8233  
 
 8234  
             // AST REWRITE
 8235  
             // elements: triplesTemplate, triplesTemplate, quadsNotTriples
 8236  
             // token labels: 
 8237  
             // rule labels: retval
 8238  
             // token list labels: 
 8239  
             // rule list labels: 
 8240  
             // wildcard labels: 
 8241  122
             retval.tree = root_0;
 8242  122
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8243  
 
 8244  122
             root_0 = (Object)adaptor.nil();
 8245  
             // 270:65: -> ( triplesTemplate )? ( quadsNotTriples ( triplesTemplate )? )*
 8246  
             {
 8247  
                 // com\\googlecode\\sparkleg\\Sparql.g:270:69: ( triplesTemplate )?
 8248  122
                 if ( stream_triplesTemplate.hasNext() ) {
 8249  88
                     adaptor.addChild(root_0, stream_triplesTemplate.nextTree());
 8250  
 
 8251  
                 }
 8252  122
                 stream_triplesTemplate.reset();
 8253  
 
 8254  
                 // com\\googlecode\\sparkleg\\Sparql.g:270:86: ( quadsNotTriples ( triplesTemplate )? )*
 8255  156
                 while ( stream_quadsNotTriples.hasNext() ) {
 8256  34
                     adaptor.addChild(root_0, stream_quadsNotTriples.nextTree());
 8257  
 
 8258  
                     // com\\googlecode\\sparkleg\\Sparql.g:270:103: ( triplesTemplate )?
 8259  34
                     if ( stream_triplesTemplate.hasNext() ) {
 8260  0
                         adaptor.addChild(root_0, stream_triplesTemplate.nextTree());
 8261  
 
 8262  
                     }
 8263  34
                     stream_triplesTemplate.reset();
 8264  
 
 8265  
                 }
 8266  122
                 stream_quadsNotTriples.reset();
 8267  
 
 8268  
             }
 8269  
 
 8270  
 
 8271  122
             retval.tree = root_0;
 8272  
 
 8273  
             }
 8274  
 
 8275  122
             retval.stop = input.LT(-1);
 8276  
 
 8277  
 
 8278  122
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8279  122
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8280  
 
 8281  
         }
 8282  0
         catch (RecognitionException re) {
 8283  0
             reportError(re);
 8284  0
             recover(input,re);
 8285  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8286  
 
 8287  
         }
 8288  
 
 8289  0
         finally {
 8290  
                 // do for sure before leaving
 8291  122
         }
 8292  122
         return retval;
 8293  
     }
 8294  
     // $ANTLR end "quads"
 8295  
 
 8296  
 
 8297  34
     public static class quadsNotTriples_return extends ParserRuleReturnScope {
 8298  
         Object tree;
 8299  34
         public Object getTree() { return tree; }
 8300  
     };
 8301  
 
 8302  
 
 8303  
     // $ANTLR start "quadsNotTriples"
 8304  
     // com\\googlecode\\sparkleg\\Sparql.g:273:1: quadsNotTriples : GRAPH varOrIRIref OPEN_CURLY_BRACE ( triplesTemplate )? CLOSE_CURLY_BRACE -> ^( GRAPH varOrIRIref ( triplesTemplate )? ) ;
 8305  
     public final SparqlParser.quadsNotTriples_return quadsNotTriples() throws RecognitionException {
 8306  34
         SparqlParser.quadsNotTriples_return retval = new SparqlParser.quadsNotTriples_return();
 8307  34
         retval.start = input.LT(1);
 8308  
 
 8309  
 
 8310  34
         Object root_0 = null;
 8311  
 
 8312  34
         Token GRAPH184=null;
 8313  34
         Token OPEN_CURLY_BRACE186=null;
 8314  34
         Token CLOSE_CURLY_BRACE188=null;
 8315  34
         SparqlParser.varOrIRIref_return varOrIRIref185 =null;
 8316  
 
 8317  34
         SparqlParser.triplesTemplate_return triplesTemplate187 =null;
 8318  
 
 8319  
 
 8320  34
         Object GRAPH184_tree=null;
 8321  34
         Object OPEN_CURLY_BRACE186_tree=null;
 8322  34
         Object CLOSE_CURLY_BRACE188_tree=null;
 8323  34
         RewriteRuleTokenStream stream_GRAPH=new RewriteRuleTokenStream(adaptor,"token GRAPH");
 8324  34
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 8325  34
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 8326  34
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 8327  34
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8328  
         try {
 8329  
             // com\\googlecode\\sparkleg\\Sparql.g:274:5: ( GRAPH varOrIRIref OPEN_CURLY_BRACE ( triplesTemplate )? CLOSE_CURLY_BRACE -> ^( GRAPH varOrIRIref ( triplesTemplate )? ) )
 8330  
             // com\\googlecode\\sparkleg\\Sparql.g:274:7: GRAPH varOrIRIref OPEN_CURLY_BRACE ( triplesTemplate )? CLOSE_CURLY_BRACE
 8331  
             {
 8332  34
             GRAPH184=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_quadsNotTriples2188);  
 8333  34
             stream_GRAPH.add(GRAPH184);
 8334  
 
 8335  
 
 8336  34
             pushFollow(FOLLOW_varOrIRIref_in_quadsNotTriples2190);
 8337  34
             varOrIRIref185=varOrIRIref();
 8338  
 
 8339  34
             state._fsp--;
 8340  
 
 8341  34
             stream_varOrIRIref.add(varOrIRIref185.getTree());
 8342  
 
 8343  34
             OPEN_CURLY_BRACE186=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_quadsNotTriples2192);  
 8344  34
             stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE186);
 8345  
 
 8346  
 
 8347  
             // com\\googlecode\\sparkleg\\Sparql.g:274:42: ( triplesTemplate )?
 8348  34
             int alt62=2;
 8349  34
             switch ( input.LA(1) ) {
 8350  
                 case BLANK_NODE_LABEL:
 8351  
                 case DECIMAL:
 8352  
                 case DECIMAL_NEGATIVE:
 8353  
                 case DECIMAL_POSITIVE:
 8354  
                 case DOUBLE:
 8355  
                 case DOUBLE_NEGATIVE:
 8356  
                 case DOUBLE_POSITIVE:
 8357  
                 case FALSE:
 8358  
                 case INTEGER:
 8359  
                 case INTEGER_NEGATIVE:
 8360  
                 case INTEGER_POSITIVE:
 8361  
                 case IRI_REF:
 8362  
                 case OPEN_BRACE:
 8363  
                 case OPEN_SQUARE_BRACKET:
 8364  
                 case PNAME_LN:
 8365  
                 case PNAME_NS:
 8366  
                 case STRING_LITERAL1:
 8367  
                 case STRING_LITERAL2:
 8368  
                 case STRING_LITERAL_LONG1:
 8369  
                 case STRING_LITERAL_LONG2:
 8370  
                 case TRUE:
 8371  
                 case VAR1:
 8372  
                 case VAR2:
 8373  
                     {
 8374  34
                     alt62=1;
 8375  
                     }
 8376  
                     break;
 8377  
             }
 8378  
 
 8379  34
             switch (alt62) {
 8380  
                 case 1 :
 8381  
                     // com\\googlecode\\sparkleg\\Sparql.g:274:42: triplesTemplate
 8382  
                     {
 8383  34
                     pushFollow(FOLLOW_triplesTemplate_in_quadsNotTriples2194);
 8384  34
                     triplesTemplate187=triplesTemplate();
 8385  
 
 8386  34
                     state._fsp--;
 8387  
 
 8388  34
                     stream_triplesTemplate.add(triplesTemplate187.getTree());
 8389  
 
 8390  
                     }
 8391  
                     break;
 8392  
 
 8393  
             }
 8394  
 
 8395  
 
 8396  34
             CLOSE_CURLY_BRACE188=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_quadsNotTriples2197);  
 8397  34
             stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE188);
 8398  
 
 8399  
 
 8400  
             // AST REWRITE
 8401  
             // elements: varOrIRIref, GRAPH, triplesTemplate
 8402  
             // token labels: 
 8403  
             // rule labels: retval
 8404  
             // token list labels: 
 8405  
             // rule list labels: 
 8406  
             // wildcard labels: 
 8407  34
             retval.tree = root_0;
 8408  34
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8409  
 
 8410  34
             root_0 = (Object)adaptor.nil();
 8411  
             // 274:77: -> ^( GRAPH varOrIRIref ( triplesTemplate )? )
 8412  
             {
 8413  
                 // com\\googlecode\\sparkleg\\Sparql.g:274:80: ^( GRAPH varOrIRIref ( triplesTemplate )? )
 8414  
                 {
 8415  34
                 Object root_1 = (Object)adaptor.nil();
 8416  34
                 root_1 = (Object)adaptor.becomeRoot(
 8417  
                 stream_GRAPH.nextNode()
 8418  
                 , root_1);
 8419  
 
 8420  34
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 8421  
 
 8422  
                 // com\\googlecode\\sparkleg\\Sparql.g:274:100: ( triplesTemplate )?
 8423  34
                 if ( stream_triplesTemplate.hasNext() ) {
 8424  34
                     adaptor.addChild(root_1, stream_triplesTemplate.nextTree());
 8425  
 
 8426  
                 }
 8427  34
                 stream_triplesTemplate.reset();
 8428  
 
 8429  34
                 adaptor.addChild(root_0, root_1);
 8430  
                 }
 8431  
 
 8432  
             }
 8433  
 
 8434  
 
 8435  34
             retval.tree = root_0;
 8436  
 
 8437  
             }
 8438  
 
 8439  34
             retval.stop = input.LT(-1);
 8440  
 
 8441  
 
 8442  34
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8443  34
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8444  
 
 8445  
         }
 8446  0
         catch (RecognitionException re) {
 8447  0
             reportError(re);
 8448  0
             recover(input,re);
 8449  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8450  
 
 8451  
         }
 8452  
 
 8453  0
         finally {
 8454  
                 // do for sure before leaving
 8455  34
         }
 8456  34
         return retval;
 8457  
     }
 8458  
     // $ANTLR end "quadsNotTriples"
 8459  
 
 8460  
 
 8461  122
     public static class triplesTemplate_return extends ParserRuleReturnScope {
 8462  
         Object tree;
 8463  122
         public Object getTree() { return tree; }
 8464  
     };
 8465  
 
 8466  
 
 8467  
     // $ANTLR start "triplesTemplate"
 8468  
     // com\\googlecode\\sparkleg\\Sparql.g:277:1: triplesTemplate : triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) ;
 8469  
     public final SparqlParser.triplesTemplate_return triplesTemplate() throws RecognitionException {
 8470  122
         SparqlParser.triplesTemplate_return retval = new SparqlParser.triplesTemplate_return();
 8471  122
         retval.start = input.LT(1);
 8472  
 
 8473  
 
 8474  122
         Object root_0 = null;
 8475  
 
 8476  122
         Token DOT190=null;
 8477  122
         Token DOT192=null;
 8478  122
         SparqlParser.triplesSameSubject_return triplesSameSubject189 =null;
 8479  
 
 8480  122
         SparqlParser.triplesSameSubject_return triplesSameSubject191 =null;
 8481  
 
 8482  
 
 8483  122
         Object DOT190_tree=null;
 8484  122
         Object DOT192_tree=null;
 8485  122
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 8486  122
         RewriteRuleSubtreeStream stream_triplesSameSubject=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubject");
 8487  
         try {
 8488  
             // com\\googlecode\\sparkleg\\Sparql.g:278:5: ( triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) )
 8489  
             // com\\googlecode\\sparkleg\\Sparql.g:278:7: triplesSameSubject ( DOT triplesSameSubject )* ( DOT )?
 8490  
             {
 8491  122
             pushFollow(FOLLOW_triplesSameSubject_in_triplesTemplate2229);
 8492  122
             triplesSameSubject189=triplesSameSubject();
 8493  
 
 8494  122
             state._fsp--;
 8495  
 
 8496  122
             stream_triplesSameSubject.add(triplesSameSubject189.getTree());
 8497  
 
 8498  
             // com\\googlecode\\sparkleg\\Sparql.g:278:26: ( DOT triplesSameSubject )*
 8499  
             loop63:
 8500  
             do {
 8501  126
                 int alt63=2;
 8502  126
                 switch ( input.LA(1) ) {
 8503  
                 case DOT:
 8504  
                     {
 8505  82
                     switch ( input.LA(2) ) {
 8506  
                     case BLANK_NODE_LABEL:
 8507  
                     case DECIMAL:
 8508  
                     case DECIMAL_NEGATIVE:
 8509  
                     case DECIMAL_POSITIVE:
 8510  
                     case DOUBLE:
 8511  
                     case DOUBLE_NEGATIVE:
 8512  
                     case DOUBLE_POSITIVE:
 8513  
                     case FALSE:
 8514  
                     case INTEGER:
 8515  
                     case INTEGER_NEGATIVE:
 8516  
                     case INTEGER_POSITIVE:
 8517  
                     case IRI_REF:
 8518  
                     case OPEN_BRACE:
 8519  
                     case OPEN_SQUARE_BRACKET:
 8520  
                     case PNAME_LN:
 8521  
                     case PNAME_NS:
 8522  
                     case STRING_LITERAL1:
 8523  
                     case STRING_LITERAL2:
 8524  
                     case STRING_LITERAL_LONG1:
 8525  
                     case STRING_LITERAL_LONG2:
 8526  
                     case TRUE:
 8527  
                     case VAR1:
 8528  
                     case VAR2:
 8529  
                         {
 8530  4
                         alt63=1;
 8531  
                         }
 8532  
                         break;
 8533  
 
 8534  
                     }
 8535  
 
 8536  
                     }
 8537  
                     break;
 8538  
 
 8539  
                 }
 8540  
 
 8541  126
                 switch (alt63) {
 8542  
                     case 1 :
 8543  
                         // com\\googlecode\\sparkleg\\Sparql.g:278:27: DOT triplesSameSubject
 8544  
                         {
 8545  4
                         DOT190=(Token)match(input,DOT,FOLLOW_DOT_in_triplesTemplate2232);  
 8546  4
                         stream_DOT.add(DOT190);
 8547  
 
 8548  
 
 8549  4
                         pushFollow(FOLLOW_triplesSameSubject_in_triplesTemplate2234);
 8550  4
                         triplesSameSubject191=triplesSameSubject();
 8551  
 
 8552  4
                         state._fsp--;
 8553  
 
 8554  4
                         stream_triplesSameSubject.add(triplesSameSubject191.getTree());
 8555  
 
 8556  
                         }
 8557  4
                         break;
 8558  
 
 8559  
                     default :
 8560  122
                         break loop63;
 8561  
                 }
 8562  4
             } while (true);
 8563  
 
 8564  
 
 8565  
             // com\\googlecode\\sparkleg\\Sparql.g:278:52: ( DOT )?
 8566  122
             int alt64=2;
 8567  122
             switch ( input.LA(1) ) {
 8568  
                 case DOT:
 8569  
                     {
 8570  78
                     alt64=1;
 8571  
                     }
 8572  
                     break;
 8573  
             }
 8574  
 
 8575  122
             switch (alt64) {
 8576  
                 case 1 :
 8577  
                     // com\\googlecode\\sparkleg\\Sparql.g:278:52: DOT
 8578  
                     {
 8579  78
                     DOT192=(Token)match(input,DOT,FOLLOW_DOT_in_triplesTemplate2238);  
 8580  78
                     stream_DOT.add(DOT192);
 8581  
 
 8582  
 
 8583  
                     }
 8584  
                     break;
 8585  
 
 8586  
             }
 8587  
 
 8588  
 
 8589  
             // AST REWRITE
 8590  
             // elements: triplesSameSubject
 8591  
             // token labels: 
 8592  
             // rule labels: retval
 8593  
             // token list labels: 
 8594  
             // rule list labels: 
 8595  
             // wildcard labels: 
 8596  122
             retval.tree = root_0;
 8597  122
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8598  
 
 8599  122
             root_0 = (Object)adaptor.nil();
 8600  
             // 278:57: -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* )
 8601  
             {
 8602  
                 // com\\googlecode\\sparkleg\\Sparql.g:278:60: ^( TRIPLES_TEMPLATE ( triplesSameSubject )* )
 8603  
                 {
 8604  122
                 Object root_1 = (Object)adaptor.nil();
 8605  122
                 root_1 = (Object)adaptor.becomeRoot(
 8606  
                 (Object)adaptor.create(TRIPLES_TEMPLATE, "TRIPLES_TEMPLATE")
 8607  
                 , root_1);
 8608  
 
 8609  
                 // com\\googlecode\\sparkleg\\Sparql.g:278:79: ( triplesSameSubject )*
 8610  248
                 while ( stream_triplesSameSubject.hasNext() ) {
 8611  126
                     adaptor.addChild(root_1, stream_triplesSameSubject.nextTree());
 8612  
 
 8613  
                 }
 8614  122
                 stream_triplesSameSubject.reset();
 8615  
 
 8616  122
                 adaptor.addChild(root_0, root_1);
 8617  
                 }
 8618  
 
 8619  
             }
 8620  
 
 8621  
 
 8622  122
             retval.tree = root_0;
 8623  
 
 8624  
             }
 8625  
 
 8626  122
             retval.stop = input.LT(-1);
 8627  
 
 8628  
 
 8629  122
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8630  122
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8631  
 
 8632  
         }
 8633  0
         catch (RecognitionException re) {
 8634  0
             reportError(re);
 8635  0
             recover(input,re);
 8636  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8637  
 
 8638  
         }
 8639  
 
 8640  0
         finally {
 8641  
                 // do for sure before leaving
 8642  122
         }
 8643  122
         return retval;
 8644  
     }
 8645  
     // $ANTLR end "triplesTemplate"
 8646  
 
 8647  
 
 8648  2710
     public static class groupGraphPattern_return extends ParserRuleReturnScope {
 8649  
         Object tree;
 8650  2710
         public Object getTree() { return tree; }
 8651  
     };
 8652  
 
 8653  
 
 8654  
     // $ANTLR start "groupGraphPattern"
 8655  
     // com\\googlecode\\sparkleg\\Sparql.g:281:1: groupGraphPattern : ( OPEN_CURLY_BRACE subSelect CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN subSelect ) | OPEN_CURLY_BRACE groupGraphPatternSub CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | OPEN_CURLY_BRACE CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) );
 8656  
     public final SparqlParser.groupGraphPattern_return groupGraphPattern() throws RecognitionException {
 8657  2710
         SparqlParser.groupGraphPattern_return retval = new SparqlParser.groupGraphPattern_return();
 8658  2710
         retval.start = input.LT(1);
 8659  
 
 8660  
 
 8661  2710
         Object root_0 = null;
 8662  
 
 8663  2710
         Token OPEN_CURLY_BRACE193=null;
 8664  2710
         Token CLOSE_CURLY_BRACE195=null;
 8665  2710
         Token OPEN_CURLY_BRACE196=null;
 8666  2710
         Token CLOSE_CURLY_BRACE198=null;
 8667  2710
         Token OPEN_CURLY_BRACE199=null;
 8668  2710
         Token CLOSE_CURLY_BRACE200=null;
 8669  2710
         SparqlParser.subSelect_return subSelect194 =null;
 8670  
 
 8671  2710
         SparqlParser.groupGraphPatternSub_return groupGraphPatternSub197 =null;
 8672  
 
 8673  
 
 8674  2710
         Object OPEN_CURLY_BRACE193_tree=null;
 8675  2710
         Object CLOSE_CURLY_BRACE195_tree=null;
 8676  2710
         Object OPEN_CURLY_BRACE196_tree=null;
 8677  2710
         Object CLOSE_CURLY_BRACE198_tree=null;
 8678  2710
         Object OPEN_CURLY_BRACE199_tree=null;
 8679  2710
         Object CLOSE_CURLY_BRACE200_tree=null;
 8680  2710
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 8681  2710
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 8682  2710
         RewriteRuleSubtreeStream stream_groupGraphPatternSub=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPatternSub");
 8683  2710
         RewriteRuleSubtreeStream stream_subSelect=new RewriteRuleSubtreeStream(adaptor,"rule subSelect");
 8684  
         try {
 8685  
             // com\\googlecode\\sparkleg\\Sparql.g:282:5: ( OPEN_CURLY_BRACE subSelect CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN subSelect ) | OPEN_CURLY_BRACE groupGraphPatternSub CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | OPEN_CURLY_BRACE CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) )
 8686  2710
             int alt65=3;
 8687  2710
             switch ( input.LA(1) ) {
 8688  
             case OPEN_CURLY_BRACE:
 8689  
                 {
 8690  2698
                 switch ( input.LA(2) ) {
 8691  
                 case CLOSE_CURLY_BRACE:
 8692  
                     {
 8693  44
                     alt65=3;
 8694  
                     }
 8695  44
                     break;
 8696  
                 case SELECT:
 8697  
                     {
 8698  46
                     alt65=1;
 8699  
                     }
 8700  46
                     break;
 8701  
                 case BIND:
 8702  
                 case BLANK_NODE_LABEL:
 8703  
                 case DECIMAL:
 8704  
                 case DECIMAL_NEGATIVE:
 8705  
                 case DECIMAL_POSITIVE:
 8706  
                 case DOUBLE:
 8707  
                 case DOUBLE_NEGATIVE:
 8708  
                 case DOUBLE_POSITIVE:
 8709  
                 case FALSE:
 8710  
                 case FILTER:
 8711  
                 case GRAPH:
 8712  
                 case INTEGER:
 8713  
                 case INTEGER_NEGATIVE:
 8714  
                 case INTEGER_POSITIVE:
 8715  
                 case IRI_REF:
 8716  
                 case MINUS_KEYWORD:
 8717  
                 case OPEN_BRACE:
 8718  
                 case OPEN_CURLY_BRACE:
 8719  
                 case OPEN_SQUARE_BRACKET:
 8720  
                 case OPTIONAL:
 8721  
                 case PNAME_LN:
 8722  
                 case PNAME_NS:
 8723  
                 case SERVICE:
 8724  
                 case STRING_LITERAL1:
 8725  
                 case STRING_LITERAL2:
 8726  
                 case STRING_LITERAL_LONG1:
 8727  
                 case STRING_LITERAL_LONG2:
 8728  
                 case TRUE:
 8729  
                 case VAR1:
 8730  
                 case VAR2:
 8731  
                     {
 8732  2598
                     alt65=2;
 8733  
                     }
 8734  2598
                     break;
 8735  
                 default:
 8736  10
                     NoViableAltException nvae =
 8737  
                         new NoViableAltException("", 65, 1, input);
 8738  
 
 8739  10
                     throw nvae;
 8740  
 
 8741  
                 }
 8742  
 
 8743  
                 }
 8744  2688
                 break;
 8745  
             default:
 8746  12
                 NoViableAltException nvae =
 8747  
                     new NoViableAltException("", 65, 0, input);
 8748  
 
 8749  12
                 throw nvae;
 8750  
 
 8751  
             }
 8752  
 
 8753  2688
             switch (alt65) {
 8754  
                 case 1 :
 8755  
                     // com\\googlecode\\sparkleg\\Sparql.g:282:7: OPEN_CURLY_BRACE subSelect CLOSE_CURLY_BRACE
 8756  
                     {
 8757  46
                     OPEN_CURLY_BRACE193=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2270);  
 8758  46
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE193);
 8759  
 
 8760  
 
 8761  46
                     pushFollow(FOLLOW_subSelect_in_groupGraphPattern2272);
 8762  46
                     subSelect194=subSelect();
 8763  
 
 8764  46
                     state._fsp--;
 8765  
 
 8766  46
                     stream_subSelect.add(subSelect194.getTree());
 8767  
 
 8768  46
                     CLOSE_CURLY_BRACE195=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2274);  
 8769  46
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE195);
 8770  
 
 8771  
 
 8772  
                     // AST REWRITE
 8773  
                     // elements: subSelect
 8774  
                     // token labels: 
 8775  
                     // rule labels: retval
 8776  
                     // token list labels: 
 8777  
                     // rule list labels: 
 8778  
                     // wildcard labels: 
 8779  46
                     retval.tree = root_0;
 8780  46
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8781  
 
 8782  46
                     root_0 = (Object)adaptor.nil();
 8783  
                     // 282:52: -> ^( GROUP_GRAPH_PATTERN subSelect )
 8784  
                     {
 8785  
                         // com\\googlecode\\sparkleg\\Sparql.g:282:55: ^( GROUP_GRAPH_PATTERN subSelect )
 8786  
                         {
 8787  46
                         Object root_1 = (Object)adaptor.nil();
 8788  46
                         root_1 = (Object)adaptor.becomeRoot(
 8789  
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 8790  
                         , root_1);
 8791  
 
 8792  46
                         adaptor.addChild(root_1, stream_subSelect.nextTree());
 8793  
 
 8794  46
                         adaptor.addChild(root_0, root_1);
 8795  
                         }
 8796  
 
 8797  
                     }
 8798  
 
 8799  
 
 8800  46
                     retval.tree = root_0;
 8801  
 
 8802  
                     }
 8803  46
                     break;
 8804  
                 case 2 :
 8805  
                     // com\\googlecode\\sparkleg\\Sparql.g:283:7: OPEN_CURLY_BRACE groupGraphPatternSub CLOSE_CURLY_BRACE
 8806  
                     {
 8807  2598
                     OPEN_CURLY_BRACE196=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2290);  
 8808  2598
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE196);
 8809  
 
 8810  
 
 8811  2598
                     pushFollow(FOLLOW_groupGraphPatternSub_in_groupGraphPattern2292);
 8812  2598
                     groupGraphPatternSub197=groupGraphPatternSub();
 8813  
 
 8814  2598
                     state._fsp--;
 8815  
 
 8816  2598
                     stream_groupGraphPatternSub.add(groupGraphPatternSub197.getTree());
 8817  
 
 8818  2598
                     CLOSE_CURLY_BRACE198=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2294);  
 8819  2580
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE198);
 8820  
 
 8821  
 
 8822  
                     // AST REWRITE
 8823  
                     // elements: groupGraphPatternSub
 8824  
                     // token labels: 
 8825  
                     // rule labels: retval
 8826  
                     // token list labels: 
 8827  
                     // rule list labels: 
 8828  
                     // wildcard labels: 
 8829  2580
                     retval.tree = root_0;
 8830  2580
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8831  
 
 8832  2580
                     root_0 = (Object)adaptor.nil();
 8833  
                     // 283:63: -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub )
 8834  
                     {
 8835  
                         // com\\googlecode\\sparkleg\\Sparql.g:283:66: ^( GROUP_GRAPH_PATTERN groupGraphPatternSub )
 8836  
                         {
 8837  2580
                         Object root_1 = (Object)adaptor.nil();
 8838  2580
                         root_1 = (Object)adaptor.becomeRoot(
 8839  
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 8840  
                         , root_1);
 8841  
 
 8842  2580
                         adaptor.addChild(root_1, stream_groupGraphPatternSub.nextTree());
 8843  
 
 8844  2580
                         adaptor.addChild(root_0, root_1);
 8845  
                         }
 8846  
 
 8847  
                     }
 8848  
 
 8849  
 
 8850  2580
                     retval.tree = root_0;
 8851  
 
 8852  
                     }
 8853  2580
                     break;
 8854  
                 case 3 :
 8855  
                     // com\\googlecode\\sparkleg\\Sparql.g:284:7: OPEN_CURLY_BRACE CLOSE_CURLY_BRACE
 8856  
                     {
 8857  44
                     OPEN_CURLY_BRACE199=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2310);  
 8858  44
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE199);
 8859  
 
 8860  
 
 8861  44
                     CLOSE_CURLY_BRACE200=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2312);  
 8862  44
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE200);
 8863  
 
 8864  
 
 8865  
                     // AST REWRITE
 8866  
                     // elements: 
 8867  
                     // token labels: 
 8868  
                     // rule labels: retval
 8869  
                     // token list labels: 
 8870  
                     // rule list labels: 
 8871  
                     // wildcard labels: 
 8872  44
                     retval.tree = root_0;
 8873  44
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8874  
 
 8875  44
                     root_0 = (Object)adaptor.nil();
 8876  
                     // 284:42: -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN )
 8877  
                     {
 8878  
                         // com\\googlecode\\sparkleg\\Sparql.g:284:45: ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN )
 8879  
                         {
 8880  44
                         Object root_1 = (Object)adaptor.nil();
 8881  44
                         root_1 = (Object)adaptor.becomeRoot(
 8882  
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 8883  
                         , root_1);
 8884  
 
 8885  44
                         adaptor.addChild(root_1, 
 8886  
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 8887  
                         );
 8888  
 
 8889  44
                         adaptor.addChild(root_0, root_1);
 8890  
                         }
 8891  
 
 8892  
                     }
 8893  
 
 8894  
 
 8895  44
                     retval.tree = root_0;
 8896  
 
 8897  
                     }
 8898  
                     break;
 8899  
 
 8900  
             }
 8901  2670
             retval.stop = input.LT(-1);
 8902  
 
 8903  
 
 8904  2670
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8905  2670
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8906  
 
 8907  
         }
 8908  40
         catch (RecognitionException re) {
 8909  40
             reportError(re);
 8910  40
             recover(input,re);
 8911  40
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8912  
 
 8913  
         }
 8914  
 
 8915  0
         finally {
 8916  
                 // do for sure before leaving
 8917  2710
         }
 8918  2710
         return retval;
 8919  
     }
 8920  
     // $ANTLR end "groupGraphPattern"
 8921  
 
 8922  
 
 8923  2598
     public static class groupGraphPatternSub_return extends ParserRuleReturnScope {
 8924  
         Object tree;
 8925  2598
         public Object getTree() { return tree; }
 8926  
     };
 8927  
 
 8928  
 
 8929  
     // $ANTLR start "groupGraphPatternSub"
 8930  
     // com\\googlecode\\sparkleg\\Sparql.g:287:1: groupGraphPatternSub : ( triplesBlock ( groupGraphPatternSubDetail )* -> triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ -> ( groupGraphPatternSubDetail )+ );
 8931  
     public final SparqlParser.groupGraphPatternSub_return groupGraphPatternSub() throws RecognitionException {
 8932  2598
         SparqlParser.groupGraphPatternSub_return retval = new SparqlParser.groupGraphPatternSub_return();
 8933  2598
         retval.start = input.LT(1);
 8934  
 
 8935  
 
 8936  2598
         Object root_0 = null;
 8937  
 
 8938  2598
         SparqlParser.triplesBlock_return triplesBlock201 =null;
 8939  
 
 8940  2598
         SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail202 =null;
 8941  
 
 8942  2598
         SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail203 =null;
 8943  
 
 8944  
 
 8945  2598
         RewriteRuleSubtreeStream stream_triplesBlock=new RewriteRuleSubtreeStream(adaptor,"rule triplesBlock");
 8946  2598
         RewriteRuleSubtreeStream stream_groupGraphPatternSubDetail=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPatternSubDetail");
 8947  
         try {
 8948  
             // com\\googlecode\\sparkleg\\Sparql.g:288:5: ( triplesBlock ( groupGraphPatternSubDetail )* -> triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ -> ( groupGraphPatternSubDetail )+ )
 8949  2598
             int alt68=2;
 8950  2598
             switch ( input.LA(1) ) {
 8951  
             case BLANK_NODE_LABEL:
 8952  
             case DECIMAL:
 8953  
             case DECIMAL_NEGATIVE:
 8954  
             case DECIMAL_POSITIVE:
 8955  
             case DOUBLE:
 8956  
             case DOUBLE_NEGATIVE:
 8957  
             case DOUBLE_POSITIVE:
 8958  
             case FALSE:
 8959  
             case INTEGER:
 8960  
             case INTEGER_NEGATIVE:
 8961  
             case INTEGER_POSITIVE:
 8962  
             case IRI_REF:
 8963  
             case OPEN_BRACE:
 8964  
             case OPEN_SQUARE_BRACKET:
 8965  
             case PNAME_LN:
 8966  
             case PNAME_NS:
 8967  
             case STRING_LITERAL1:
 8968  
             case STRING_LITERAL2:
 8969  
             case STRING_LITERAL_LONG1:
 8970  
             case STRING_LITERAL_LONG2:
 8971  
             case TRUE:
 8972  
             case VAR1:
 8973  
             case VAR2:
 8974  
                 {
 8975  2310
                 alt68=1;
 8976  
                 }
 8977  2310
                 break;
 8978  
             case BIND:
 8979  
             case FILTER:
 8980  
             case GRAPH:
 8981  
             case MINUS_KEYWORD:
 8982  
             case OPEN_CURLY_BRACE:
 8983  
             case OPTIONAL:
 8984  
             case SERVICE:
 8985  
                 {
 8986  288
                 alt68=2;
 8987  
                 }
 8988  288
                 break;
 8989  
             default:
 8990  0
                 NoViableAltException nvae =
 8991  
                     new NoViableAltException("", 68, 0, input);
 8992  
 
 8993  0
                 throw nvae;
 8994  
 
 8995  
             }
 8996  
 
 8997  2598
             switch (alt68) {
 8998  
                 case 1 :
 8999  
                     // com\\googlecode\\sparkleg\\Sparql.g:288:7: triplesBlock ( groupGraphPatternSubDetail )*
 9000  
                     {
 9001  2310
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSub2341);
 9002  2310
                     triplesBlock201=triplesBlock();
 9003  
 
 9004  2310
                     state._fsp--;
 9005  
 
 9006  2310
                     stream_triplesBlock.add(triplesBlock201.getTree());
 9007  
 
 9008  
                     // com\\googlecode\\sparkleg\\Sparql.g:288:20: ( groupGraphPatternSubDetail )*
 9009  
                     loop66:
 9010  
                     do {
 9011  3192
                         int alt66=2;
 9012  3192
                         switch ( input.LA(1) ) {
 9013  
                         case BIND:
 9014  
                         case FILTER:
 9015  
                         case GRAPH:
 9016  
                         case MINUS_KEYWORD:
 9017  
                         case OPEN_CURLY_BRACE:
 9018  
                         case OPTIONAL:
 9019  
                         case SERVICE:
 9020  
                             {
 9021  882
                             alt66=1;
 9022  
                             }
 9023  
                             break;
 9024  
 
 9025  
                         }
 9026  
 
 9027  3192
                         switch (alt66) {
 9028  
                             case 1 :
 9029  
                                 // com\\googlecode\\sparkleg\\Sparql.g:288:20: groupGraphPatternSubDetail
 9030  
                                 {
 9031  882
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2343);
 9032  882
                                 groupGraphPatternSubDetail202=groupGraphPatternSubDetail();
 9033  
 
 9034  882
                                 state._fsp--;
 9035  
 
 9036  882
                                 stream_groupGraphPatternSubDetail.add(groupGraphPatternSubDetail202.getTree());
 9037  
 
 9038  
                                 }
 9039  882
                                 break;
 9040  
 
 9041  
                             default :
 9042  2310
                                 break loop66;
 9043  
                         }
 9044  882
                     } while (true);
 9045  
 
 9046  
 
 9047  
                     // AST REWRITE
 9048  
                     // elements: groupGraphPatternSubDetail, triplesBlock
 9049  
                     // token labels: 
 9050  
                     // rule labels: retval
 9051  
                     // token list labels: 
 9052  
                     // rule list labels: 
 9053  
                     // wildcard labels: 
 9054  2310
                     retval.tree = root_0;
 9055  2310
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9056  
 
 9057  2310
                     root_0 = (Object)adaptor.nil();
 9058  
                     // 288:48: -> triplesBlock ( groupGraphPatternSubDetail )*
 9059  
                     {
 9060  2310
                         adaptor.addChild(root_0, stream_triplesBlock.nextTree());
 9061  
 
 9062  
                         // com\\googlecode\\sparkleg\\Sparql.g:288:64: ( groupGraphPatternSubDetail )*
 9063  3192
                         while ( stream_groupGraphPatternSubDetail.hasNext() ) {
 9064  882
                             adaptor.addChild(root_0, stream_groupGraphPatternSubDetail.nextTree());
 9065  
 
 9066  
                         }
 9067  2310
                         stream_groupGraphPatternSubDetail.reset();
 9068  
 
 9069  
                     }
 9070  
 
 9071  
 
 9072  2310
                     retval.tree = root_0;
 9073  
 
 9074  
                     }
 9075  2310
                     break;
 9076  
                 case 2 :
 9077  
                     // com\\googlecode\\sparkleg\\Sparql.g:289:7: ( groupGraphPatternSubDetail )+
 9078  
                     {
 9079  
                     // com\\googlecode\\sparkleg\\Sparql.g:289:7: ( groupGraphPatternSubDetail )+
 9080  288
                     int cnt67=0;
 9081  
                     loop67:
 9082  
                     do {
 9083  650
                         int alt67=2;
 9084  650
                         switch ( input.LA(1) ) {
 9085  
                         case BIND:
 9086  
                         case FILTER:
 9087  
                         case GRAPH:
 9088  
                         case MINUS_KEYWORD:
 9089  
                         case OPEN_CURLY_BRACE:
 9090  
                         case OPTIONAL:
 9091  
                         case SERVICE:
 9092  
                             {
 9093  362
                             alt67=1;
 9094  
                             }
 9095  
                             break;
 9096  
 
 9097  
                         }
 9098  
 
 9099  650
                         switch (alt67) {
 9100  
                             case 1 :
 9101  
                                 // com\\googlecode\\sparkleg\\Sparql.g:289:7: groupGraphPatternSubDetail
 9102  
                                 {
 9103  362
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2359);
 9104  362
                                 groupGraphPatternSubDetail203=groupGraphPatternSubDetail();
 9105  
 
 9106  362
                                 state._fsp--;
 9107  
 
 9108  362
                                 stream_groupGraphPatternSubDetail.add(groupGraphPatternSubDetail203.getTree());
 9109  
 
 9110  
                                 }
 9111  362
                                 break;
 9112  
 
 9113  
                             default :
 9114  288
                                 if ( cnt67 >= 1 ) break loop67;
 9115  0
                                 EarlyExitException eee =
 9116  
                                     new EarlyExitException(67, input);
 9117  0
                                 throw eee;
 9118  
                         }
 9119  362
                         cnt67++;
 9120  362
                     } while (true);
 9121  
 
 9122  
 
 9123  
                     // AST REWRITE
 9124  
                     // elements: groupGraphPatternSubDetail
 9125  
                     // token labels: 
 9126  
                     // rule labels: retval
 9127  
                     // token list labels: 
 9128  
                     // rule list labels: 
 9129  
                     // wildcard labels: 
 9130  288
                     retval.tree = root_0;
 9131  288
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9132  
 
 9133  288
                     root_0 = (Object)adaptor.nil();
 9134  
                     // 289:35: -> ( groupGraphPatternSubDetail )+
 9135  
                     {
 9136  288
                         if ( !(stream_groupGraphPatternSubDetail.hasNext()) ) {
 9137  0
                             throw new RewriteEarlyExitException();
 9138  
                         }
 9139  650
                         while ( stream_groupGraphPatternSubDetail.hasNext() ) {
 9140  362
                             adaptor.addChild(root_0, stream_groupGraphPatternSubDetail.nextTree());
 9141  
 
 9142  
                         }
 9143  288
                         stream_groupGraphPatternSubDetail.reset();
 9144  
 
 9145  
                     }
 9146  
 
 9147  
 
 9148  288
                     retval.tree = root_0;
 9149  
 
 9150  
                     }
 9151  
                     break;
 9152  
 
 9153  
             }
 9154  2598
             retval.stop = input.LT(-1);
 9155  
 
 9156  
 
 9157  2598
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9158  2598
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9159  
 
 9160  
         }
 9161  0
         catch (RecognitionException re) {
 9162  0
             reportError(re);
 9163  0
             recover(input,re);
 9164  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9165  
 
 9166  
         }
 9167  
 
 9168  0
         finally {
 9169  
                 // do for sure before leaving
 9170  2598
         }
 9171  2598
         return retval;
 9172  
     }
 9173  
     // $ANTLR end "groupGraphPatternSub"
 9174  
 
 9175  
 
 9176  1244
     public static class groupGraphPatternSubDetail_return extends ParserRuleReturnScope {
 9177  
         Object tree;
 9178  1244
         public Object getTree() { return tree; }
 9179  
     };
 9180  
 
 9181  
 
 9182  
     // $ANTLR start "groupGraphPatternSubDetail"
 9183  
     // com\\googlecode\\sparkleg\\Sparql.g:292:1: groupGraphPatternSubDetail : graphPatternNotTriples ( DOT )? ( triplesBlock )? -> graphPatternNotTriples ( triplesBlock )? ;
 9184  
     public final SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail() throws RecognitionException {
 9185  1244
         SparqlParser.groupGraphPatternSubDetail_return retval = new SparqlParser.groupGraphPatternSubDetail_return();
 9186  1244
         retval.start = input.LT(1);
 9187  
 
 9188  
 
 9189  1244
         Object root_0 = null;
 9190  
 
 9191  1244
         Token DOT205=null;
 9192  1244
         SparqlParser.graphPatternNotTriples_return graphPatternNotTriples204 =null;
 9193  
 
 9194  1244
         SparqlParser.triplesBlock_return triplesBlock206 =null;
 9195  
 
 9196  
 
 9197  1244
         Object DOT205_tree=null;
 9198  1244
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 9199  1244
         RewriteRuleSubtreeStream stream_triplesBlock=new RewriteRuleSubtreeStream(adaptor,"rule triplesBlock");
 9200  1244
         RewriteRuleSubtreeStream stream_graphPatternNotTriples=new RewriteRuleSubtreeStream(adaptor,"rule graphPatternNotTriples");
 9201  
         try {
 9202  
             // com\\googlecode\\sparkleg\\Sparql.g:293:5: ( graphPatternNotTriples ( DOT )? ( triplesBlock )? -> graphPatternNotTriples ( triplesBlock )? )
 9203  
             // com\\googlecode\\sparkleg\\Sparql.g:293:7: graphPatternNotTriples ( DOT )? ( triplesBlock )?
 9204  
             {
 9205  1244
             pushFollow(FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail2382);
 9206  1244
             graphPatternNotTriples204=graphPatternNotTriples();
 9207  
 
 9208  1244
             state._fsp--;
 9209  
 
 9210  1244
             stream_graphPatternNotTriples.add(graphPatternNotTriples204.getTree());
 9211  
 
 9212  
             // com\\googlecode\\sparkleg\\Sparql.g:293:30: ( DOT )?
 9213  1244
             int alt69=2;
 9214  1244
             switch ( input.LA(1) ) {
 9215  
                 case DOT:
 9216  
                     {
 9217  196
                     alt69=1;
 9218  
                     }
 9219  
                     break;
 9220  
             }
 9221  
 
 9222  1244
             switch (alt69) {
 9223  
                 case 1 :
 9224  
                     // com\\googlecode\\sparkleg\\Sparql.g:293:30: DOT
 9225  
                     {
 9226  196
                     DOT205=(Token)match(input,DOT,FOLLOW_DOT_in_groupGraphPatternSubDetail2384);  
 9227  196
                     stream_DOT.add(DOT205);
 9228  
 
 9229  
 
 9230  
                     }
 9231  
                     break;
 9232  
 
 9233  
             }
 9234  
 
 9235  
 
 9236  
             // com\\googlecode\\sparkleg\\Sparql.g:293:35: ( triplesBlock )?
 9237  1244
             int alt70=2;
 9238  1244
             switch ( input.LA(1) ) {
 9239  
                 case BLANK_NODE_LABEL:
 9240  
                 case DECIMAL:
 9241  
                 case DECIMAL_NEGATIVE:
 9242  
                 case DECIMAL_POSITIVE:
 9243  
                 case DOUBLE:
 9244  
                 case DOUBLE_NEGATIVE:
 9245  
                 case DOUBLE_POSITIVE:
 9246  
                 case FALSE:
 9247  
                 case INTEGER:
 9248  
                 case INTEGER_NEGATIVE:
 9249  
                 case INTEGER_POSITIVE:
 9250  
                 case IRI_REF:
 9251  
                 case OPEN_BRACE:
 9252  
                 case OPEN_SQUARE_BRACKET:
 9253  
                 case PNAME_LN:
 9254  
                 case PNAME_NS:
 9255  
                 case STRING_LITERAL1:
 9256  
                 case STRING_LITERAL2:
 9257  
                 case STRING_LITERAL_LONG1:
 9258  
                 case STRING_LITERAL_LONG2:
 9259  
                 case TRUE:
 9260  
                 case VAR1:
 9261  
                 case VAR2:
 9262  
                     {
 9263  84
                     alt70=1;
 9264  
                     }
 9265  
                     break;
 9266  
             }
 9267  
 
 9268  1244
             switch (alt70) {
 9269  
                 case 1 :
 9270  
                     // com\\googlecode\\sparkleg\\Sparql.g:293:35: triplesBlock
 9271  
                     {
 9272  84
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSubDetail2387);
 9273  84
                     triplesBlock206=triplesBlock();
 9274  
 
 9275  84
                     state._fsp--;
 9276  
 
 9277  84
                     stream_triplesBlock.add(triplesBlock206.getTree());
 9278  
 
 9279  
                     }
 9280  
                     break;
 9281  
 
 9282  
             }
 9283  
 
 9284  
 
 9285  
             // AST REWRITE
 9286  
             // elements: triplesBlock, graphPatternNotTriples
 9287  
             // token labels: 
 9288  
             // rule labels: retval
 9289  
             // token list labels: 
 9290  
             // rule list labels: 
 9291  
             // wildcard labels: 
 9292  1244
             retval.tree = root_0;
 9293  1244
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9294  
 
 9295  1244
             root_0 = (Object)adaptor.nil();
 9296  
             // 293:49: -> graphPatternNotTriples ( triplesBlock )?
 9297  
             {
 9298  1244
                 adaptor.addChild(root_0, stream_graphPatternNotTriples.nextTree());
 9299  
 
 9300  
                 // com\\googlecode\\sparkleg\\Sparql.g:293:75: ( triplesBlock )?
 9301  1244
                 if ( stream_triplesBlock.hasNext() ) {
 9302  84
                     adaptor.addChild(root_0, stream_triplesBlock.nextTree());
 9303  
 
 9304  
                 }
 9305  1244
                 stream_triplesBlock.reset();
 9306  
 
 9307  
             }
 9308  
 
 9309  
 
 9310  1244
             retval.tree = root_0;
 9311  
 
 9312  
             }
 9313  
 
 9314  1244
             retval.stop = input.LT(-1);
 9315  
 
 9316  
 
 9317  1244
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9318  1244
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9319  
 
 9320  
         }
 9321  0
         catch (RecognitionException re) {
 9322  0
             reportError(re);
 9323  0
             recover(input,re);
 9324  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9325  
 
 9326  
         }
 9327  
 
 9328  0
         finally {
 9329  
                 // do for sure before leaving
 9330  1244
         }
 9331  1244
         return retval;
 9332  
     }
 9333  
     // $ANTLR end "groupGraphPatternSubDetail"
 9334  
 
 9335  
 
 9336  2394
     public static class triplesBlock_return extends ParserRuleReturnScope {
 9337  
         Object tree;
 9338  2394
         public Object getTree() { return tree; }
 9339  
     };
 9340  
 
 9341  
 
 9342  
     // $ANTLR start "triplesBlock"
 9343  
     // com\\googlecode\\sparkleg\\Sparql.g:296:1: triplesBlock : triplesSameSubjectPath ( DOT triplesSameSubjectPath )* ( DOT )? -> ( triplesSameSubjectPath )+ ;
 9344  
     public final SparqlParser.triplesBlock_return triplesBlock() throws RecognitionException {
 9345  2394
         SparqlParser.triplesBlock_return retval = new SparqlParser.triplesBlock_return();
 9346  2394
         retval.start = input.LT(1);
 9347  
 
 9348  
 
 9349  2394
         Object root_0 = null;
 9350  
 
 9351  2394
         Token DOT208=null;
 9352  2394
         Token DOT210=null;
 9353  2394
         SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath207 =null;
 9354  
 
 9355  2394
         SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath209 =null;
 9356  
 
 9357  
 
 9358  2394
         Object DOT208_tree=null;
 9359  2394
         Object DOT210_tree=null;
 9360  2394
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 9361  2394
         RewriteRuleSubtreeStream stream_triplesSameSubjectPath=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubjectPath");
 9362  
         try {
 9363  
             // com\\googlecode\\sparkleg\\Sparql.g:297:5: ( triplesSameSubjectPath ( DOT triplesSameSubjectPath )* ( DOT )? -> ( triplesSameSubjectPath )+ )
 9364  
             // com\\googlecode\\sparkleg\\Sparql.g:297:7: triplesSameSubjectPath ( DOT triplesSameSubjectPath )* ( DOT )?
 9365  
             {
 9366  2394
             pushFollow(FOLLOW_triplesSameSubjectPath_in_triplesBlock2412);
 9367  2394
             triplesSameSubjectPath207=triplesSameSubjectPath();
 9368  
 
 9369  2394
             state._fsp--;
 9370  
 
 9371  2394
             stream_triplesSameSubjectPath.add(triplesSameSubjectPath207.getTree());
 9372  
 
 9373  
             // com\\googlecode\\sparkleg\\Sparql.g:297:30: ( DOT triplesSameSubjectPath )*
 9374  
             loop71:
 9375  
             do {
 9376  2964
                 int alt71=2;
 9377  2964
                 switch ( input.LA(1) ) {
 9378  
                 case DOT:
 9379  
                     {
 9380  1484
                     switch ( input.LA(2) ) {
 9381  
                     case BLANK_NODE_LABEL:
 9382  
                     case DECIMAL:
 9383  
                     case DECIMAL_NEGATIVE:
 9384  
                     case DECIMAL_POSITIVE:
 9385  
                     case DOUBLE:
 9386  
                     case DOUBLE_NEGATIVE:
 9387  
                     case DOUBLE_POSITIVE:
 9388  
                     case FALSE:
 9389  
                     case INTEGER:
 9390  
                     case INTEGER_NEGATIVE:
 9391  
                     case INTEGER_POSITIVE:
 9392  
                     case IRI_REF:
 9393  
                     case OPEN_BRACE:
 9394  
                     case OPEN_SQUARE_BRACKET:
 9395  
                     case PNAME_LN:
 9396  
                     case PNAME_NS:
 9397  
                     case STRING_LITERAL1:
 9398  
                     case STRING_LITERAL2:
 9399  
                     case STRING_LITERAL_LONG1:
 9400  
                     case STRING_LITERAL_LONG2:
 9401  
                     case TRUE:
 9402  
                     case VAR1:
 9403  
                     case VAR2:
 9404  
                         {
 9405  570
                         alt71=1;
 9406  
                         }
 9407  
                         break;
 9408  
 
 9409  
                     }
 9410  
 
 9411  
                     }
 9412  
                     break;
 9413  
 
 9414  
                 }
 9415  
 
 9416  2964
                 switch (alt71) {
 9417  
                     case 1 :
 9418  
                         // com\\googlecode\\sparkleg\\Sparql.g:297:31: DOT triplesSameSubjectPath
 9419  
                         {
 9420  570
                         DOT208=(Token)match(input,DOT,FOLLOW_DOT_in_triplesBlock2415);  
 9421  570
                         stream_DOT.add(DOT208);
 9422  
 
 9423  
 
 9424  570
                         pushFollow(FOLLOW_triplesSameSubjectPath_in_triplesBlock2417);
 9425  570
                         triplesSameSubjectPath209=triplesSameSubjectPath();
 9426  
 
 9427  570
                         state._fsp--;
 9428  
 
 9429  570
                         stream_triplesSameSubjectPath.add(triplesSameSubjectPath209.getTree());
 9430  
 
 9431  
                         }
 9432  570
                         break;
 9433  
 
 9434  
                     default :
 9435  2394
                         break loop71;
 9436  
                 }
 9437  570
             } while (true);
 9438  
 
 9439  
 
 9440  
             // com\\googlecode\\sparkleg\\Sparql.g:297:60: ( DOT )?
 9441  2394
             int alt72=2;
 9442  2394
             switch ( input.LA(1) ) {
 9443  
                 case DOT:
 9444  
                     {
 9445  914
                     alt72=1;
 9446  
                     }
 9447  
                     break;
 9448  
             }
 9449  
 
 9450  2394
             switch (alt72) {
 9451  
                 case 1 :
 9452  
                     // com\\googlecode\\sparkleg\\Sparql.g:297:60: DOT
 9453  
                     {
 9454  914
                     DOT210=(Token)match(input,DOT,FOLLOW_DOT_in_triplesBlock2421);  
 9455  914
                     stream_DOT.add(DOT210);
 9456  
 
 9457  
 
 9458  
                     }
 9459  
                     break;
 9460  
 
 9461  
             }
 9462  
 
 9463  
 
 9464  
             // AST REWRITE
 9465  
             // elements: triplesSameSubjectPath
 9466  
             // token labels: 
 9467  
             // rule labels: retval
 9468  
             // token list labels: 
 9469  
             // rule list labels: 
 9470  
             // wildcard labels: 
 9471  2394
             retval.tree = root_0;
 9472  2394
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9473  
 
 9474  2394
             root_0 = (Object)adaptor.nil();
 9475  
             // 297:65: -> ( triplesSameSubjectPath )+
 9476  
             {
 9477  2394
                 if ( !(stream_triplesSameSubjectPath.hasNext()) ) {
 9478  0
                     throw new RewriteEarlyExitException();
 9479  
                 }
 9480  5358
                 while ( stream_triplesSameSubjectPath.hasNext() ) {
 9481  2964
                     adaptor.addChild(root_0, stream_triplesSameSubjectPath.nextTree());
 9482  
 
 9483  
                 }
 9484  2394
                 stream_triplesSameSubjectPath.reset();
 9485  
 
 9486  
             }
 9487  
 
 9488  
 
 9489  2394
             retval.tree = root_0;
 9490  
 
 9491  
             }
 9492  
 
 9493  2394
             retval.stop = input.LT(-1);
 9494  
 
 9495  
 
 9496  2394
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9497  2394
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9498  
 
 9499  
         }
 9500  0
         catch (RecognitionException re) {
 9501  0
             reportError(re);
 9502  0
             recover(input,re);
 9503  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9504  
 
 9505  
         }
 9506  
 
 9507  0
         finally {
 9508  
                 // do for sure before leaving
 9509  2394
         }
 9510  2394
         return retval;
 9511  
     }
 9512  
     // $ANTLR end "triplesBlock"
 9513  
 
 9514  
 
 9515  1244
     public static class graphPatternNotTriples_return extends ParserRuleReturnScope {
 9516  
         Object tree;
 9517  1244
         public Object getTree() { return tree; }
 9518  
     };
 9519  
 
 9520  
 
 9521  
     // $ANTLR start "graphPatternNotTriples"
 9522  
     // com\\googlecode\\sparkleg\\Sparql.g:300:1: graphPatternNotTriples : ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind );
 9523  
     public final SparqlParser.graphPatternNotTriples_return graphPatternNotTriples() throws RecognitionException {
 9524  1244
         SparqlParser.graphPatternNotTriples_return retval = new SparqlParser.graphPatternNotTriples_return();
 9525  1244
         retval.start = input.LT(1);
 9526  
 
 9527  
 
 9528  1244
         Object root_0 = null;
 9529  
 
 9530  1244
         SparqlParser.groupOrUnionGraphPattern_return groupOrUnionGraphPattern211 =null;
 9531  
 
 9532  1244
         SparqlParser.optionalGraphPattern_return optionalGraphPattern212 =null;
 9533  
 
 9534  1244
         SparqlParser.minusGraphPattern_return minusGraphPattern213 =null;
 9535  
 
 9536  1244
         SparqlParser.graphGraphPattern_return graphGraphPattern214 =null;
 9537  
 
 9538  1244
         SparqlParser.serviceGraphPattern_return serviceGraphPattern215 =null;
 9539  
 
 9540  1244
         SparqlParser.filter_return filter216 =null;
 9541  
 
 9542  1244
         SparqlParser.bind_return bind217 =null;
 9543  
 
 9544  
 
 9545  
 
 9546  
         try {
 9547  
             // com\\googlecode\\sparkleg\\Sparql.g:301:5: ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind )
 9548  1244
             int alt73=7;
 9549  1244
             switch ( input.LA(1) ) {
 9550  
             case OPEN_CURLY_BRACE:
 9551  
                 {
 9552  178
                 alt73=1;
 9553  
                 }
 9554  178
                 break;
 9555  
             case OPTIONAL:
 9556  
                 {
 9557  194
                 alt73=2;
 9558  
                 }
 9559  194
                 break;
 9560  
             case MINUS_KEYWORD:
 9561  
                 {
 9562  42
                 alt73=3;
 9563  
                 }
 9564  42
                 break;
 9565  
             case GRAPH:
 9566  
                 {
 9567  156
                 alt73=4;
 9568  
                 }
 9569  156
                 break;
 9570  
             case SERVICE:
 9571  
                 {
 9572  26
                 alt73=5;
 9573  
                 }
 9574  26
                 break;
 9575  
             case FILTER:
 9576  
                 {
 9577  598
                 alt73=6;
 9578  
                 }
 9579  598
                 break;
 9580  
             case BIND:
 9581  
                 {
 9582  50
                 alt73=7;
 9583  
                 }
 9584  50
                 break;
 9585  
             default:
 9586  0
                 NoViableAltException nvae =
 9587  
                     new NoViableAltException("", 73, 0, input);
 9588  
 
 9589  0
                 throw nvae;
 9590  
 
 9591  
             }
 9592  
 
 9593  1244
             switch (alt73) {
 9594  
                 case 1 :
 9595  
                     // com\\googlecode\\sparkleg\\Sparql.g:301:7: groupOrUnionGraphPattern
 9596  
                     {
 9597  178
                     root_0 = (Object)adaptor.nil();
 9598  
 
 9599  
 
 9600  178
                     pushFollow(FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples2444);
 9601  178
                     groupOrUnionGraphPattern211=groupOrUnionGraphPattern();
 9602  
 
 9603  178
                     state._fsp--;
 9604  
 
 9605  178
                     adaptor.addChild(root_0, groupOrUnionGraphPattern211.getTree());
 9606  
 
 9607  
                     }
 9608  178
                     break;
 9609  
                 case 2 :
 9610  
                     // com\\googlecode\\sparkleg\\Sparql.g:301:34: optionalGraphPattern
 9611  
                     {
 9612  194
                     root_0 = (Object)adaptor.nil();
 9613  
 
 9614  
 
 9615  194
                     pushFollow(FOLLOW_optionalGraphPattern_in_graphPatternNotTriples2448);
 9616  194
                     optionalGraphPattern212=optionalGraphPattern();
 9617  
 
 9618  194
                     state._fsp--;
 9619  
 
 9620  194
                     adaptor.addChild(root_0, optionalGraphPattern212.getTree());
 9621  
 
 9622  
                     }
 9623  194
                     break;
 9624  
                 case 3 :
 9625  
                     // com\\googlecode\\sparkleg\\Sparql.g:301:57: minusGraphPattern
 9626  
                     {
 9627  42
                     root_0 = (Object)adaptor.nil();
 9628  
 
 9629  
 
 9630  42
                     pushFollow(FOLLOW_minusGraphPattern_in_graphPatternNotTriples2452);
 9631  42
                     minusGraphPattern213=minusGraphPattern();
 9632  
 
 9633  42
                     state._fsp--;
 9634  
 
 9635  42
                     adaptor.addChild(root_0, minusGraphPattern213.getTree());
 9636  
 
 9637  
                     }
 9638  42
                     break;
 9639  
                 case 4 :
 9640  
                     // com\\googlecode\\sparkleg\\Sparql.g:301:77: graphGraphPattern
 9641  
                     {
 9642  156
                     root_0 = (Object)adaptor.nil();
 9643  
 
 9644  
 
 9645  156
                     pushFollow(FOLLOW_graphGraphPattern_in_graphPatternNotTriples2456);
 9646  156
                     graphGraphPattern214=graphGraphPattern();
 9647  
 
 9648  156
                     state._fsp--;
 9649  
 
 9650  156
                     adaptor.addChild(root_0, graphGraphPattern214.getTree());
 9651  
 
 9652  
                     }
 9653  156
                     break;
 9654  
                 case 5 :
 9655  
                     // com\\googlecode\\sparkleg\\Sparql.g:301:97: serviceGraphPattern
 9656  
                     {
 9657  26
                     root_0 = (Object)adaptor.nil();
 9658  
 
 9659  
 
 9660  26
                     pushFollow(FOLLOW_serviceGraphPattern_in_graphPatternNotTriples2460);
 9661  26
                     serviceGraphPattern215=serviceGraphPattern();
 9662  
 
 9663  26
                     state._fsp--;
 9664  
 
 9665  26
                     adaptor.addChild(root_0, serviceGraphPattern215.getTree());
 9666  
 
 9667  
                     }
 9668  26
                     break;
 9669  
                 case 6 :
 9670  
                     // com\\googlecode\\sparkleg\\Sparql.g:301:119: filter
 9671  
                     {
 9672  598
                     root_0 = (Object)adaptor.nil();
 9673  
 
 9674  
 
 9675  598
                     pushFollow(FOLLOW_filter_in_graphPatternNotTriples2464);
 9676  598
                     filter216=filter();
 9677  
 
 9678  598
                     state._fsp--;
 9679  
 
 9680  598
                     adaptor.addChild(root_0, filter216.getTree());
 9681  
 
 9682  
                     }
 9683  598
                     break;
 9684  
                 case 7 :
 9685  
                     // com\\googlecode\\sparkleg\\Sparql.g:301:128: bind
 9686  
                     {
 9687  50
                     root_0 = (Object)adaptor.nil();
 9688  
 
 9689  
 
 9690  50
                     pushFollow(FOLLOW_bind_in_graphPatternNotTriples2468);
 9691  50
                     bind217=bind();
 9692  
 
 9693  50
                     state._fsp--;
 9694  
 
 9695  50
                     adaptor.addChild(root_0, bind217.getTree());
 9696  
 
 9697  
                     }
 9698  
                     break;
 9699  
 
 9700  
             }
 9701  1244
             retval.stop = input.LT(-1);
 9702  
 
 9703  
 
 9704  1244
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9705  1244
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9706  
 
 9707  
         }
 9708  0
         catch (RecognitionException re) {
 9709  0
             reportError(re);
 9710  0
             recover(input,re);
 9711  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9712  
 
 9713  
         }
 9714  
 
 9715  0
         finally {
 9716  
                 // do for sure before leaving
 9717  1244
         }
 9718  1244
         return retval;
 9719  
     }
 9720  
     // $ANTLR end "graphPatternNotTriples"
 9721  
 
 9722  
 
 9723  194
     public static class optionalGraphPattern_return extends ParserRuleReturnScope {
 9724  
         Object tree;
 9725  194
         public Object getTree() { return tree; }
 9726  
     };
 9727  
 
 9728  
 
 9729  
     // $ANTLR start "optionalGraphPattern"
 9730  
     // com\\googlecode\\sparkleg\\Sparql.g:304:1: optionalGraphPattern : OPTIONAL groupGraphPattern -> ^( OPTIONAL groupGraphPattern ) ;
 9731  
     public final SparqlParser.optionalGraphPattern_return optionalGraphPattern() throws RecognitionException {
 9732  194
         SparqlParser.optionalGraphPattern_return retval = new SparqlParser.optionalGraphPattern_return();
 9733  194
         retval.start = input.LT(1);
 9734  
 
 9735  
 
 9736  194
         Object root_0 = null;
 9737  
 
 9738  194
         Token OPTIONAL218=null;
 9739  194
         SparqlParser.groupGraphPattern_return groupGraphPattern219 =null;
 9740  
 
 9741  
 
 9742  194
         Object OPTIONAL218_tree=null;
 9743  194
         RewriteRuleTokenStream stream_OPTIONAL=new RewriteRuleTokenStream(adaptor,"token OPTIONAL");
 9744  194
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 9745  
         try {
 9746  
             // com\\googlecode\\sparkleg\\Sparql.g:305:5: ( OPTIONAL groupGraphPattern -> ^( OPTIONAL groupGraphPattern ) )
 9747  
             // com\\googlecode\\sparkleg\\Sparql.g:305:7: OPTIONAL groupGraphPattern
 9748  
             {
 9749  194
             OPTIONAL218=(Token)match(input,OPTIONAL,FOLLOW_OPTIONAL_in_optionalGraphPattern2485);  
 9750  194
             stream_OPTIONAL.add(OPTIONAL218);
 9751  
 
 9752  
 
 9753  194
             pushFollow(FOLLOW_groupGraphPattern_in_optionalGraphPattern2487);
 9754  194
             groupGraphPattern219=groupGraphPattern();
 9755  
 
 9756  194
             state._fsp--;
 9757  
 
 9758  194
             stream_groupGraphPattern.add(groupGraphPattern219.getTree());
 9759  
 
 9760  
             // AST REWRITE
 9761  
             // elements: OPTIONAL, groupGraphPattern
 9762  
             // token labels: 
 9763  
             // rule labels: retval
 9764  
             // token list labels: 
 9765  
             // rule list labels: 
 9766  
             // wildcard labels: 
 9767  194
             retval.tree = root_0;
 9768  194
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9769  
 
 9770  194
             root_0 = (Object)adaptor.nil();
 9771  
             // 305:34: -> ^( OPTIONAL groupGraphPattern )
 9772  
             {
 9773  
                 // com\\googlecode\\sparkleg\\Sparql.g:305:37: ^( OPTIONAL groupGraphPattern )
 9774  
                 {
 9775  194
                 Object root_1 = (Object)adaptor.nil();
 9776  194
                 root_1 = (Object)adaptor.becomeRoot(
 9777  
                 stream_OPTIONAL.nextNode()
 9778  
                 , root_1);
 9779  
 
 9780  194
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 9781  
 
 9782  194
                 adaptor.addChild(root_0, root_1);
 9783  
                 }
 9784  
 
 9785  
             }
 9786  
 
 9787  
 
 9788  194
             retval.tree = root_0;
 9789  
 
 9790  
             }
 9791  
 
 9792  194
             retval.stop = input.LT(-1);
 9793  
 
 9794  
 
 9795  194
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9796  194
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9797  
 
 9798  
         }
 9799  0
         catch (RecognitionException re) {
 9800  0
             reportError(re);
 9801  0
             recover(input,re);
 9802  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9803  
 
 9804  
         }
 9805  
 
 9806  0
         finally {
 9807  
                 // do for sure before leaving
 9808  194
         }
 9809  194
         return retval;
 9810  
     }
 9811  
     // $ANTLR end "optionalGraphPattern"
 9812  
 
 9813  
 
 9814  156
     public static class graphGraphPattern_return extends ParserRuleReturnScope {
 9815  
         Object tree;
 9816  156
         public Object getTree() { return tree; }
 9817  
     };
 9818  
 
 9819  
 
 9820  
     // $ANTLR start "graphGraphPattern"
 9821  
     // com\\googlecode\\sparkleg\\Sparql.g:308:1: graphGraphPattern : GRAPH varOrIRIref groupGraphPattern -> ^( GRAPH varOrIRIref groupGraphPattern ) ;
 9822  
     public final SparqlParser.graphGraphPattern_return graphGraphPattern() throws RecognitionException {
 9823  156
         SparqlParser.graphGraphPattern_return retval = new SparqlParser.graphGraphPattern_return();
 9824  156
         retval.start = input.LT(1);
 9825  
 
 9826  
 
 9827  156
         Object root_0 = null;
 9828  
 
 9829  156
         Token GRAPH220=null;
 9830  156
         SparqlParser.varOrIRIref_return varOrIRIref221 =null;
 9831  
 
 9832  156
         SparqlParser.groupGraphPattern_return groupGraphPattern222 =null;
 9833  
 
 9834  
 
 9835  156
         Object GRAPH220_tree=null;
 9836  156
         RewriteRuleTokenStream stream_GRAPH=new RewriteRuleTokenStream(adaptor,"token GRAPH");
 9837  156
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 9838  156
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 9839  
         try {
 9840  
             // com\\googlecode\\sparkleg\\Sparql.g:309:5: ( GRAPH varOrIRIref groupGraphPattern -> ^( GRAPH varOrIRIref groupGraphPattern ) )
 9841  
             // com\\googlecode\\sparkleg\\Sparql.g:309:7: GRAPH varOrIRIref groupGraphPattern
 9842  
             {
 9843  156
             GRAPH220=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphGraphPattern2512);  
 9844  156
             stream_GRAPH.add(GRAPH220);
 9845  
 
 9846  
 
 9847  156
             pushFollow(FOLLOW_varOrIRIref_in_graphGraphPattern2514);
 9848  156
             varOrIRIref221=varOrIRIref();
 9849  
 
 9850  156
             state._fsp--;
 9851  
 
 9852  156
             stream_varOrIRIref.add(varOrIRIref221.getTree());
 9853  
 
 9854  156
             pushFollow(FOLLOW_groupGraphPattern_in_graphGraphPattern2516);
 9855  156
             groupGraphPattern222=groupGraphPattern();
 9856  
 
 9857  156
             state._fsp--;
 9858  
 
 9859  156
             stream_groupGraphPattern.add(groupGraphPattern222.getTree());
 9860  
 
 9861  
             // AST REWRITE
 9862  
             // elements: varOrIRIref, GRAPH, groupGraphPattern
 9863  
             // token labels: 
 9864  
             // rule labels: retval
 9865  
             // token list labels: 
 9866  
             // rule list labels: 
 9867  
             // wildcard labels: 
 9868  156
             retval.tree = root_0;
 9869  156
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9870  
 
 9871  156
             root_0 = (Object)adaptor.nil();
 9872  
             // 309:43: -> ^( GRAPH varOrIRIref groupGraphPattern )
 9873  
             {
 9874  
                 // com\\googlecode\\sparkleg\\Sparql.g:309:46: ^( GRAPH varOrIRIref groupGraphPattern )
 9875  
                 {
 9876  156
                 Object root_1 = (Object)adaptor.nil();
 9877  156
                 root_1 = (Object)adaptor.becomeRoot(
 9878  
                 stream_GRAPH.nextNode()
 9879  
                 , root_1);
 9880  
 
 9881  156
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 9882  
 
 9883  156
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 9884  
 
 9885  156
                 adaptor.addChild(root_0, root_1);
 9886  
                 }
 9887  
 
 9888  
             }
 9889  
 
 9890  
 
 9891  156
             retval.tree = root_0;
 9892  
 
 9893  
             }
 9894  
 
 9895  156
             retval.stop = input.LT(-1);
 9896  
 
 9897  
 
 9898  156
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9899  156
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9900  
 
 9901  
         }
 9902  0
         catch (RecognitionException re) {
 9903  0
             reportError(re);
 9904  0
             recover(input,re);
 9905  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9906  
 
 9907  
         }
 9908  
 
 9909  0
         finally {
 9910  
                 // do for sure before leaving
 9911  156
         }
 9912  156
         return retval;
 9913  
     }
 9914  
     // $ANTLR end "graphGraphPattern"
 9915  
 
 9916  
 
 9917  26
     public static class serviceGraphPattern_return extends ParserRuleReturnScope {
 9918  
         Object tree;
 9919  26
         public Object getTree() { return tree; }
 9920  
     };
 9921  
 
 9922  
 
 9923  
     // $ANTLR start "serviceGraphPattern"
 9924  
     // com\\googlecode\\sparkleg\\Sparql.g:312:1: serviceGraphPattern : SERVICE ( SILENT )? varOrIRIref groupGraphPattern -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) ;
 9925  
     public final SparqlParser.serviceGraphPattern_return serviceGraphPattern() throws RecognitionException {
 9926  26
         SparqlParser.serviceGraphPattern_return retval = new SparqlParser.serviceGraphPattern_return();
 9927  26
         retval.start = input.LT(1);
 9928  
 
 9929  
 
 9930  26
         Object root_0 = null;
 9931  
 
 9932  26
         Token SERVICE223=null;
 9933  26
         Token SILENT224=null;
 9934  26
         SparqlParser.varOrIRIref_return varOrIRIref225 =null;
 9935  
 
 9936  26
         SparqlParser.groupGraphPattern_return groupGraphPattern226 =null;
 9937  
 
 9938  
 
 9939  26
         Object SERVICE223_tree=null;
 9940  26
         Object SILENT224_tree=null;
 9941  26
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 9942  26
         RewriteRuleTokenStream stream_SERVICE=new RewriteRuleTokenStream(adaptor,"token SERVICE");
 9943  26
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 9944  26
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 9945  
         try {
 9946  
             // com\\googlecode\\sparkleg\\Sparql.g:313:5: ( SERVICE ( SILENT )? varOrIRIref groupGraphPattern -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) )
 9947  
             // com\\googlecode\\sparkleg\\Sparql.g:313:7: SERVICE ( SILENT )? varOrIRIref groupGraphPattern
 9948  
             {
 9949  26
             SERVICE223=(Token)match(input,SERVICE,FOLLOW_SERVICE_in_serviceGraphPattern2543);  
 9950  26
             stream_SERVICE.add(SERVICE223);
 9951  
 
 9952  
 
 9953  
             // com\\googlecode\\sparkleg\\Sparql.g:313:15: ( SILENT )?
 9954  26
             int alt74=2;
 9955  26
             switch ( input.LA(1) ) {
 9956  
                 case SILENT:
 9957  
                     {
 9958  6
                     alt74=1;
 9959  
                     }
 9960  
                     break;
 9961  
             }
 9962  
 
 9963  26
             switch (alt74) {
 9964  
                 case 1 :
 9965  
                     // com\\googlecode\\sparkleg\\Sparql.g:313:15: SILENT
 9966  
                     {
 9967  6
                     SILENT224=(Token)match(input,SILENT,FOLLOW_SILENT_in_serviceGraphPattern2545);  
 9968  6
                     stream_SILENT.add(SILENT224);
 9969  
 
 9970  
 
 9971  
                     }
 9972  
                     break;
 9973  
 
 9974  
             }
 9975  
 
 9976  
 
 9977  26
             pushFollow(FOLLOW_varOrIRIref_in_serviceGraphPattern2548);
 9978  26
             varOrIRIref225=varOrIRIref();
 9979  
 
 9980  26
             state._fsp--;
 9981  
 
 9982  26
             stream_varOrIRIref.add(varOrIRIref225.getTree());
 9983  
 
 9984  26
             pushFollow(FOLLOW_groupGraphPattern_in_serviceGraphPattern2550);
 9985  26
             groupGraphPattern226=groupGraphPattern();
 9986  
 
 9987  26
             state._fsp--;
 9988  
 
 9989  26
             stream_groupGraphPattern.add(groupGraphPattern226.getTree());
 9990  
 
 9991  
             // AST REWRITE
 9992  
             // elements: SERVICE, groupGraphPattern, SILENT, varOrIRIref
 9993  
             // token labels: 
 9994  
             // rule labels: retval
 9995  
             // token list labels: 
 9996  
             // rule list labels: 
 9997  
             // wildcard labels: 
 9998  26
             retval.tree = root_0;
 9999  26
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10000  
 
 10001  26
             root_0 = (Object)adaptor.nil();
 10002  
             // 313:53: -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern )
 10003  
             {
 10004  
                 // com\\googlecode\\sparkleg\\Sparql.g:313:56: ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern )
 10005  
                 {
 10006  26
                 Object root_1 = (Object)adaptor.nil();
 10007  26
                 root_1 = (Object)adaptor.becomeRoot(
 10008  
                 stream_SERVICE.nextNode()
 10009  
                 , root_1);
 10010  
 
 10011  
                 // com\\googlecode\\sparkleg\\Sparql.g:313:66: ( SILENT )?
 10012  26
                 if ( stream_SILENT.hasNext() ) {
 10013  6
                     adaptor.addChild(root_1, 
 10014  
                     stream_SILENT.nextNode()
 10015  
                     );
 10016  
 
 10017  
                 }
 10018  26
                 stream_SILENT.reset();
 10019  
 
 10020  26
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 10021  
 
 10022  26
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10023  
 
 10024  26
                 adaptor.addChild(root_0, root_1);
 10025  
                 }
 10026  
 
 10027  
             }
 10028  
 
 10029  
 
 10030  26
             retval.tree = root_0;
 10031  
 
 10032  
             }
 10033  
 
 10034  26
             retval.stop = input.LT(-1);
 10035  
 
 10036  
 
 10037  26
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10038  26
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10039  
 
 10040  
         }
 10041  0
         catch (RecognitionException re) {
 10042  0
             reportError(re);
 10043  0
             recover(input,re);
 10044  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10045  
 
 10046  
         }
 10047  
 
 10048  0
         finally {
 10049  
                 // do for sure before leaving
 10050  26
         }
 10051  26
         return retval;
 10052  
     }
 10053  
     // $ANTLR end "serviceGraphPattern"
 10054  
 
 10055  
 
 10056  50
     public static class bind_return extends ParserRuleReturnScope {
 10057  
         Object tree;
 10058  50
         public Object getTree() { return tree; }
 10059  
     };
 10060  
 
 10061  
 
 10062  
     // $ANTLR start "bind"
 10063  
     // com\\googlecode\\sparkleg\\Sparql.g:316:1: bind : BIND OPEN_BRACE expression AS var CLOSE_BRACE -> ^( BIND expression ^( AS var ) ) ;
 10064  
     public final SparqlParser.bind_return bind() throws RecognitionException {
 10065  50
         SparqlParser.bind_return retval = new SparqlParser.bind_return();
 10066  50
         retval.start = input.LT(1);
 10067  
 
 10068  
 
 10069  50
         Object root_0 = null;
 10070  
 
 10071  50
         Token BIND227=null;
 10072  50
         Token OPEN_BRACE228=null;
 10073  50
         Token AS230=null;
 10074  50
         Token CLOSE_BRACE232=null;
 10075  50
         SparqlParser.expression_return expression229 =null;
 10076  
 
 10077  50
         SparqlParser.var_return var231 =null;
 10078  
 
 10079  
 
 10080  50
         Object BIND227_tree=null;
 10081  50
         Object OPEN_BRACE228_tree=null;
 10082  50
         Object AS230_tree=null;
 10083  50
         Object CLOSE_BRACE232_tree=null;
 10084  50
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 10085  50
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 10086  50
         RewriteRuleTokenStream stream_BIND=new RewriteRuleTokenStream(adaptor,"token BIND");
 10087  50
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 10088  50
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 10089  50
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 10090  
         try {
 10091  
             // com\\googlecode\\sparkleg\\Sparql.g:317:5: ( BIND OPEN_BRACE expression AS var CLOSE_BRACE -> ^( BIND expression ^( AS var ) ) )
 10092  
             // com\\googlecode\\sparkleg\\Sparql.g:317:7: BIND OPEN_BRACE expression AS var CLOSE_BRACE
 10093  
             {
 10094  50
             BIND227=(Token)match(input,BIND,FOLLOW_BIND_in_bind2584);  
 10095  50
             stream_BIND.add(BIND227);
 10096  
 
 10097  
 
 10098  50
             OPEN_BRACE228=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_bind2586);  
 10099  50
             stream_OPEN_BRACE.add(OPEN_BRACE228);
 10100  
 
 10101  
 
 10102  50
             pushFollow(FOLLOW_expression_in_bind2588);
 10103  50
             expression229=expression();
 10104  
 
 10105  50
             state._fsp--;
 10106  
 
 10107  50
             stream_expression.add(expression229.getTree());
 10108  
 
 10109  50
             AS230=(Token)match(input,AS,FOLLOW_AS_in_bind2590);  
 10110  50
             stream_AS.add(AS230);
 10111  
 
 10112  
 
 10113  50
             pushFollow(FOLLOW_var_in_bind2592);
 10114  50
             var231=var();
 10115  
 
 10116  50
             state._fsp--;
 10117  
 
 10118  50
             stream_var.add(var231.getTree());
 10119  
 
 10120  50
             CLOSE_BRACE232=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_bind2594);  
 10121  50
             stream_CLOSE_BRACE.add(CLOSE_BRACE232);
 10122  
 
 10123  
 
 10124  
             // AST REWRITE
 10125  
             // elements: AS, expression, var, BIND
 10126  
             // token labels: 
 10127  
             // rule labels: retval
 10128  
             // token list labels: 
 10129  
             // rule list labels: 
 10130  
             // wildcard labels: 
 10131  50
             retval.tree = root_0;
 10132  50
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10133  
 
 10134  50
             root_0 = (Object)adaptor.nil();
 10135  
             // 317:53: -> ^( BIND expression ^( AS var ) )
 10136  
             {
 10137  
                 // com\\googlecode\\sparkleg\\Sparql.g:317:56: ^( BIND expression ^( AS var ) )
 10138  
                 {
 10139  50
                 Object root_1 = (Object)adaptor.nil();
 10140  50
                 root_1 = (Object)adaptor.becomeRoot(
 10141  
                 stream_BIND.nextNode()
 10142  
                 , root_1);
 10143  
 
 10144  50
                 adaptor.addChild(root_1, stream_expression.nextTree());
 10145  
 
 10146  
                 // com\\googlecode\\sparkleg\\Sparql.g:317:74: ^( AS var )
 10147  
                 {
 10148  50
                 Object root_2 = (Object)adaptor.nil();
 10149  50
                 root_2 = (Object)adaptor.becomeRoot(
 10150  
                 stream_AS.nextNode()
 10151  
                 , root_2);
 10152  
 
 10153  50
                 adaptor.addChild(root_2, stream_var.nextTree());
 10154  
 
 10155  50
                 adaptor.addChild(root_1, root_2);
 10156  
                 }
 10157  
 
 10158  50
                 adaptor.addChild(root_0, root_1);
 10159  
                 }
 10160  
 
 10161  
             }
 10162  
 
 10163  
 
 10164  50
             retval.tree = root_0;
 10165  
 
 10166  
             }
 10167  
 
 10168  50
             retval.stop = input.LT(-1);
 10169  
 
 10170  
 
 10171  50
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10172  50
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10173  
 
 10174  
         }
 10175  0
         catch (RecognitionException re) {
 10176  0
             reportError(re);
 10177  0
             recover(input,re);
 10178  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10179  
 
 10180  
         }
 10181  
 
 10182  0
         finally {
 10183  
                 // do for sure before leaving
 10184  50
         }
 10185  50
         return retval;
 10186  
     }
 10187  
     // $ANTLR end "bind"
 10188  
 
 10189  
 
 10190  42
     public static class minusGraphPattern_return extends ParserRuleReturnScope {
 10191  
         Object tree;
 10192  42
         public Object getTree() { return tree; }
 10193  
     };
 10194  
 
 10195  
 
 10196  
     // $ANTLR start "minusGraphPattern"
 10197  
     // com\\googlecode\\sparkleg\\Sparql.g:320:1: minusGraphPattern : MINUS_KEYWORD groupGraphPattern -> ^( MINUS_KEYWORD groupGraphPattern ) ;
 10198  
     public final SparqlParser.minusGraphPattern_return minusGraphPattern() throws RecognitionException {
 10199  42
         SparqlParser.minusGraphPattern_return retval = new SparqlParser.minusGraphPattern_return();
 10200  42
         retval.start = input.LT(1);
 10201  
 
 10202  
 
 10203  42
         Object root_0 = null;
 10204  
 
 10205  42
         Token MINUS_KEYWORD233=null;
 10206  42
         SparqlParser.groupGraphPattern_return groupGraphPattern234 =null;
 10207  
 
 10208  
 
 10209  42
         Object MINUS_KEYWORD233_tree=null;
 10210  42
         RewriteRuleTokenStream stream_MINUS_KEYWORD=new RewriteRuleTokenStream(adaptor,"token MINUS_KEYWORD");
 10211  42
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10212  
         try {
 10213  
             // com\\googlecode\\sparkleg\\Sparql.g:321:5: ( MINUS_KEYWORD groupGraphPattern -> ^( MINUS_KEYWORD groupGraphPattern ) )
 10214  
             // com\\googlecode\\sparkleg\\Sparql.g:321:7: MINUS_KEYWORD groupGraphPattern
 10215  
             {
 10216  42
             MINUS_KEYWORD233=(Token)match(input,MINUS_KEYWORD,FOLLOW_MINUS_KEYWORD_in_minusGraphPattern2631);  
 10217  42
             stream_MINUS_KEYWORD.add(MINUS_KEYWORD233);
 10218  
 
 10219  
 
 10220  42
             pushFollow(FOLLOW_groupGraphPattern_in_minusGraphPattern2633);
 10221  42
             groupGraphPattern234=groupGraphPattern();
 10222  
 
 10223  42
             state._fsp--;
 10224  
 
 10225  42
             stream_groupGraphPattern.add(groupGraphPattern234.getTree());
 10226  
 
 10227  
             // AST REWRITE
 10228  
             // elements: MINUS_KEYWORD, groupGraphPattern
 10229  
             // token labels: 
 10230  
             // rule labels: retval
 10231  
             // token list labels: 
 10232  
             // rule list labels: 
 10233  
             // wildcard labels: 
 10234  42
             retval.tree = root_0;
 10235  42
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10236  
 
 10237  42
             root_0 = (Object)adaptor.nil();
 10238  
             // 321:39: -> ^( MINUS_KEYWORD groupGraphPattern )
 10239  
             {
 10240  
                 // com\\googlecode\\sparkleg\\Sparql.g:321:42: ^( MINUS_KEYWORD groupGraphPattern )
 10241  
                 {
 10242  42
                 Object root_1 = (Object)adaptor.nil();
 10243  42
                 root_1 = (Object)adaptor.becomeRoot(
 10244  
                 stream_MINUS_KEYWORD.nextNode()
 10245  
                 , root_1);
 10246  
 
 10247  42
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10248  
 
 10249  42
                 adaptor.addChild(root_0, root_1);
 10250  
                 }
 10251  
 
 10252  
             }
 10253  
 
 10254  
 
 10255  42
             retval.tree = root_0;
 10256  
 
 10257  
             }
 10258  
 
 10259  42
             retval.stop = input.LT(-1);
 10260  
 
 10261  
 
 10262  42
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10263  42
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10264  
 
 10265  
         }
 10266  0
         catch (RecognitionException re) {
 10267  0
             reportError(re);
 10268  0
             recover(input,re);
 10269  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10270  
 
 10271  
         }
 10272  
 
 10273  0
         finally {
 10274  
                 // do for sure before leaving
 10275  42
         }
 10276  42
         return retval;
 10277  
     }
 10278  
     // $ANTLR end "minusGraphPattern"
 10279  
 
 10280  
 
 10281  178
     public static class groupOrUnionGraphPattern_return extends ParserRuleReturnScope {
 10282  
         Object tree;
 10283  178
         public Object getTree() { return tree; }
 10284  
     };
 10285  
 
 10286  
 
 10287  
     // $ANTLR start "groupOrUnionGraphPattern"
 10288  
     // com\\googlecode\\sparkleg\\Sparql.g:324:1: groupOrUnionGraphPattern : (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )* ;
 10289  
     public final SparqlParser.groupOrUnionGraphPattern_return groupOrUnionGraphPattern() throws RecognitionException {
 10290  178
         SparqlParser.groupOrUnionGraphPattern_return retval = new SparqlParser.groupOrUnionGraphPattern_return();
 10291  178
         retval.start = input.LT(1);
 10292  
 
 10293  
 
 10294  178
         Object root_0 = null;
 10295  
 
 10296  178
         Token UNION235=null;
 10297  178
         SparqlParser.groupGraphPattern_return g1 =null;
 10298  
 
 10299  178
         SparqlParser.groupGraphPattern_return g2 =null;
 10300  
 
 10301  
 
 10302  178
         Object UNION235_tree=null;
 10303  178
         RewriteRuleTokenStream stream_UNION=new RewriteRuleTokenStream(adaptor,"token UNION");
 10304  178
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10305  
         try {
 10306  
             // com\\googlecode\\sparkleg\\Sparql.g:325:5: ( (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )* )
 10307  
             // com\\googlecode\\sparkleg\\Sparql.g:325:7: (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )*
 10308  
             {
 10309  
             // com\\googlecode\\sparkleg\\Sparql.g:325:7: (g1= groupGraphPattern -> $g1)
 10310  
             // com\\googlecode\\sparkleg\\Sparql.g:325:8: g1= groupGraphPattern
 10311  
             {
 10312  178
             pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2661);
 10313  178
             g1=groupGraphPattern();
 10314  
 
 10315  178
             state._fsp--;
 10316  
 
 10317  178
             stream_groupGraphPattern.add(g1.getTree());
 10318  
 
 10319  
             // AST REWRITE
 10320  
             // elements: g1
 10321  
             // token labels: 
 10322  
             // rule labels: retval, g1
 10323  
             // token list labels: 
 10324  
             // rule list labels: 
 10325  
             // wildcard labels: 
 10326  178
             retval.tree = root_0;
 10327  178
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10328  178
             RewriteRuleSubtreeStream stream_g1=new RewriteRuleSubtreeStream(adaptor,"rule g1",g1!=null?g1.tree:null);
 10329  
 
 10330  178
             root_0 = (Object)adaptor.nil();
 10331  
             // 325:28: -> $g1
 10332  
             {
 10333  178
                 adaptor.addChild(root_0, stream_g1.nextTree());
 10334  
 
 10335  
             }
 10336  
 
 10337  
 
 10338  178
             retval.tree = root_0;
 10339  
 
 10340  
             }
 10341  
 
 10342  
 
 10343  
             // com\\googlecode\\sparkleg\\Sparql.g:325:35: ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )*
 10344  
             loop75:
 10345  
             do {
 10346  274
                 int alt75=2;
 10347  274
                 switch ( input.LA(1) ) {
 10348  
                 case UNION:
 10349  
                     {
 10350  96
                     alt75=1;
 10351  
                     }
 10352  
                     break;
 10353  
 
 10354  
                 }
 10355  
 
 10356  274
                 switch (alt75) {
 10357  
                     case 1 :
 10358  
                         // com\\googlecode\\sparkleg\\Sparql.g:325:36: ( UNION g2= groupGraphPattern )
 10359  
                         {
 10360  
                         // com\\googlecode\\sparkleg\\Sparql.g:325:36: ( UNION g2= groupGraphPattern )
 10361  
                         // com\\googlecode\\sparkleg\\Sparql.g:325:37: UNION g2= groupGraphPattern
 10362  
                         {
 10363  96
                         UNION235=(Token)match(input,UNION,FOLLOW_UNION_in_groupOrUnionGraphPattern2669);  
 10364  96
                         stream_UNION.add(UNION235);
 10365  
 
 10366  
 
 10367  96
                         pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2673);
 10368  96
                         g2=groupGraphPattern();
 10369  
 
 10370  96
                         state._fsp--;
 10371  
 
 10372  96
                         stream_groupGraphPattern.add(g2.getTree());
 10373  
 
 10374  
                         }
 10375  
 
 10376  
 
 10377  
                         // AST REWRITE
 10378  
                         // elements: UNION, g2, groupOrUnionGraphPattern
 10379  
                         // token labels: 
 10380  
                         // rule labels: retval, g2
 10381  
                         // token list labels: 
 10382  
                         // rule list labels: 
 10383  
                         // wildcard labels: 
 10384  96
                         retval.tree = root_0;
 10385  96
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10386  96
                         RewriteRuleSubtreeStream stream_g2=new RewriteRuleSubtreeStream(adaptor,"rule g2",g2!=null?g2.tree:null);
 10387  
 
 10388  96
                         root_0 = (Object)adaptor.nil();
 10389  
                         // 325:65: -> ^( UNION $groupOrUnionGraphPattern $g2)
 10390  
                         {
 10391  
                             // com\\googlecode\\sparkleg\\Sparql.g:325:68: ^( UNION $groupOrUnionGraphPattern $g2)
 10392  
                             {
 10393  96
                             Object root_1 = (Object)adaptor.nil();
 10394  96
                             root_1 = (Object)adaptor.becomeRoot(
 10395  
                             stream_UNION.nextNode()
 10396  
                             , root_1);
 10397  
 
 10398  96
                             adaptor.addChild(root_1, stream_retval.nextTree());
 10399  
 
 10400  96
                             adaptor.addChild(root_1, stream_g2.nextTree());
 10401  
 
 10402  96
                             adaptor.addChild(root_0, root_1);
 10403  
                             }
 10404  
 
 10405  
                         }
 10406  
 
 10407  
 
 10408  96
                         retval.tree = root_0;
 10409  
 
 10410  
                         }
 10411  96
                         break;
 10412  
 
 10413  
                     default :
 10414  178
                         break loop75;
 10415  
                 }
 10416  96
             } while (true);
 10417  
 
 10418  
 
 10419  
             }
 10420  
 
 10421  178
             retval.stop = input.LT(-1);
 10422  
 
 10423  
 
 10424  178
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10425  178
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10426  
 
 10427  
         }
 10428  0
         catch (RecognitionException re) {
 10429  0
             reportError(re);
 10430  0
             recover(input,re);
 10431  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10432  
 
 10433  
         }
 10434  
 
 10435  0
         finally {
 10436  
                 // do for sure before leaving
 10437  178
         }
 10438  178
         return retval;
 10439  
     }
 10440  
     // $ANTLR end "groupOrUnionGraphPattern"
 10441  
 
 10442  
 
 10443  598
     public static class filter_return extends ParserRuleReturnScope {
 10444  
         Object tree;
 10445  598
         public Object getTree() { return tree; }
 10446  
     };
 10447  
 
 10448  
 
 10449  
     // $ANTLR start "filter"
 10450  
     // com\\googlecode\\sparkleg\\Sparql.g:328:1: filter : FILTER constraint -> ^( FILTER constraint ) ;
 10451  
     public final SparqlParser.filter_return filter() throws RecognitionException {
 10452  598
         SparqlParser.filter_return retval = new SparqlParser.filter_return();
 10453  598
         retval.start = input.LT(1);
 10454  
 
 10455  
 
 10456  598
         Object root_0 = null;
 10457  
 
 10458  598
         Token FILTER236=null;
 10459  598
         SparqlParser.constraint_return constraint237 =null;
 10460  
 
 10461  
 
 10462  598
         Object FILTER236_tree=null;
 10463  598
         RewriteRuleTokenStream stream_FILTER=new RewriteRuleTokenStream(adaptor,"token FILTER");
 10464  598
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 10465  
         try {
 10466  
             // com\\googlecode\\sparkleg\\Sparql.g:329:5: ( FILTER constraint -> ^( FILTER constraint ) )
 10467  
             // com\\googlecode\\sparkleg\\Sparql.g:329:7: FILTER constraint
 10468  
             {
 10469  598
             FILTER236=(Token)match(input,FILTER,FOLLOW_FILTER_in_filter2705);  
 10470  598
             stream_FILTER.add(FILTER236);
 10471  
 
 10472  
 
 10473  598
             pushFollow(FOLLOW_constraint_in_filter2707);
 10474  598
             constraint237=constraint();
 10475  
 
 10476  598
             state._fsp--;
 10477  
 
 10478  598
             stream_constraint.add(constraint237.getTree());
 10479  
 
 10480  
             // AST REWRITE
 10481  
             // elements: FILTER, constraint
 10482  
             // token labels: 
 10483  
             // rule labels: retval
 10484  
             // token list labels: 
 10485  
             // rule list labels: 
 10486  
             // wildcard labels: 
 10487  598
             retval.tree = root_0;
 10488  598
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10489  
 
 10490  598
             root_0 = (Object)adaptor.nil();
 10491  
             // 329:25: -> ^( FILTER constraint )
 10492  
             {
 10493  
                 // com\\googlecode\\sparkleg\\Sparql.g:329:28: ^( FILTER constraint )
 10494  
                 {
 10495  598
                 Object root_1 = (Object)adaptor.nil();
 10496  598
                 root_1 = (Object)adaptor.becomeRoot(
 10497  
                 stream_FILTER.nextNode()
 10498  
                 , root_1);
 10499  
 
 10500  598
                 adaptor.addChild(root_1, stream_constraint.nextTree());
 10501  
 
 10502  598
                 adaptor.addChild(root_0, root_1);
 10503  
                 }
 10504  
 
 10505  
             }
 10506  
 
 10507  
 
 10508  598
             retval.tree = root_0;
 10509  
 
 10510  
             }
 10511  
 
 10512  598
             retval.stop = input.LT(-1);
 10513  
 
 10514  
 
 10515  598
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10516  598
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10517  
 
 10518  
         }
 10519  0
         catch (RecognitionException re) {
 10520  0
             reportError(re);
 10521  0
             recover(input,re);
 10522  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10523  
 
 10524  
         }
 10525  
 
 10526  0
         finally {
 10527  
                 // do for sure before leaving
 10528  598
         }
 10529  598
         return retval;
 10530  
     }
 10531  
     // $ANTLR end "filter"
 10532  
 
 10533  
 
 10534  626
     public static class constraint_return extends ParserRuleReturnScope {
 10535  
         Object tree;
 10536  626
         public Object getTree() { return tree; }
 10537  
     };
 10538  
 
 10539  
 
 10540  
     // $ANTLR start "constraint"
 10541  
     // com\\googlecode\\sparkleg\\Sparql.g:332:1: constraint : ( brackettedExpression | builtInCall | functionCall );
 10542  
     public final SparqlParser.constraint_return constraint() throws RecognitionException {
 10543  626
         SparqlParser.constraint_return retval = new SparqlParser.constraint_return();
 10544  626
         retval.start = input.LT(1);
 10545  
 
 10546  
 
 10547  626
         Object root_0 = null;
 10548  
 
 10549  626
         SparqlParser.brackettedExpression_return brackettedExpression238 =null;
 10550  
 
 10551  626
         SparqlParser.builtInCall_return builtInCall239 =null;
 10552  
 
 10553  626
         SparqlParser.functionCall_return functionCall240 =null;
 10554  
 
 10555  
 
 10556  
 
 10557  
         try {
 10558  
             // com\\googlecode\\sparkleg\\Sparql.g:333:5: ( brackettedExpression | builtInCall | functionCall )
 10559  626
             int alt76=3;
 10560  626
             switch ( input.LA(1) ) {
 10561  
             case OPEN_BRACE:
 10562  
                 {
 10563  458
                 alt76=1;
 10564  
                 }
 10565  458
                 break;
 10566  
             case ABS:
 10567  
             case BNODE:
 10568  
             case BOUND:
 10569  
             case CEIL:
 10570  
             case COALESCE:
 10571  
             case CONCAT:
 10572  
             case CONTAINS:
 10573  
             case DATATYPE:
 10574  
             case DAY:
 10575  
             case ENCODE_FOR_URI:
 10576  
             case EXISTS:
 10577  
             case FLOOR:
 10578  
             case HOURS:
 10579  
             case IF:
 10580  
             case IRI:
 10581  
             case ISBLANK:
 10582  
             case ISIRI:
 10583  
             case ISLITERAL:
 10584  
             case ISNUMERIC:
 10585  
             case ISURI:
 10586  
             case LANG:
 10587  
             case LANGMATCHES:
 10588  
             case LCASE:
 10589  
             case MD5:
 10590  
             case MINUTES:
 10591  
             case MONTH:
 10592  
             case NOT:
 10593  
             case NOW:
 10594  
             case RAND:
 10595  
             case REGEX:
 10596  
             case REPLACE:
 10597  
             case ROUND:
 10598  
             case SAMETERM:
 10599  
             case SECONDS:
 10600  
             case SHA1:
 10601  
             case SHA224:
 10602  
             case SHA256:
 10603  
             case SHA384:
 10604  
             case SHA512:
 10605  
             case STR:
 10606  
             case STRAFTER:
 10607  
             case STRBEFORE:
 10608  
             case STRDT:
 10609  
             case STRENDS:
 10610  
             case STRLANG:
 10611  
             case STRLEN:
 10612  
             case STRSTARTS:
 10613  
             case SUBSTR:
 10614  
             case TIMEZONE:
 10615  
             case TZ:
 10616  
             case UCASE:
 10617  
             case URI:
 10618  
             case YEAR:
 10619  
                 {
 10620  158
                 alt76=2;
 10621  
                 }
 10622  158
                 break;
 10623  
             case IRI_REF:
 10624  
             case PNAME_LN:
 10625  
             case PNAME_NS:
 10626  
                 {
 10627  8
                 alt76=3;
 10628  
                 }
 10629  8
                 break;
 10630  
             default:
 10631  2
                 NoViableAltException nvae =
 10632  
                     new NoViableAltException("", 76, 0, input);
 10633  
 
 10634  2
                 throw nvae;
 10635  
 
 10636  
             }
 10637  
 
 10638  624
             switch (alt76) {
 10639  
                 case 1 :
 10640  
                     // com\\googlecode\\sparkleg\\Sparql.g:333:7: brackettedExpression
 10641  
                     {
 10642  458
                     root_0 = (Object)adaptor.nil();
 10643  
 
 10644  
 
 10645  458
                     pushFollow(FOLLOW_brackettedExpression_in_constraint2732);
 10646  458
                     brackettedExpression238=brackettedExpression();
 10647  
 
 10648  458
                     state._fsp--;
 10649  
 
 10650  458
                     adaptor.addChild(root_0, brackettedExpression238.getTree());
 10651  
 
 10652  
                     }
 10653  458
                     break;
 10654  
                 case 2 :
 10655  
                     // com\\googlecode\\sparkleg\\Sparql.g:334:7: builtInCall
 10656  
                     {
 10657  158
                     root_0 = (Object)adaptor.nil();
 10658  
 
 10659  
 
 10660  158
                     pushFollow(FOLLOW_builtInCall_in_constraint2740);
 10661  158
                     builtInCall239=builtInCall();
 10662  
 
 10663  158
                     state._fsp--;
 10664  
 
 10665  158
                     adaptor.addChild(root_0, builtInCall239.getTree());
 10666  
 
 10667  
                     }
 10668  158
                     break;
 10669  
                 case 3 :
 10670  
                     // com\\googlecode\\sparkleg\\Sparql.g:335:7: functionCall
 10671  
                     {
 10672  8
                     root_0 = (Object)adaptor.nil();
 10673  
 
 10674  
 
 10675  8
                     pushFollow(FOLLOW_functionCall_in_constraint2748);
 10676  8
                     functionCall240=functionCall();
 10677  
 
 10678  8
                     state._fsp--;
 10679  
 
 10680  8
                     adaptor.addChild(root_0, functionCall240.getTree());
 10681  
 
 10682  
                     }
 10683  
                     break;
 10684  
 
 10685  
             }
 10686  624
             retval.stop = input.LT(-1);
 10687  
 
 10688  
 
 10689  624
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10690  624
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10691  
 
 10692  
         }
 10693  2
         catch (RecognitionException re) {
 10694  2
             reportError(re);
 10695  2
             recover(input,re);
 10696  2
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10697  
 
 10698  
         }
 10699  
 
 10700  0
         finally {
 10701  
                 // do for sure before leaving
 10702  626
         }
 10703  626
         return retval;
 10704  
     }
 10705  
     // $ANTLR end "constraint"
 10706  
 
 10707  
 
 10708  8
     public static class functionCall_return extends ParserRuleReturnScope {
 10709  
         Object tree;
 10710  8
         public Object getTree() { return tree; }
 10711  
     };
 10712  
 
 10713  
 
 10714  
     // $ANTLR start "functionCall"
 10715  
     // com\\googlecode\\sparkleg\\Sparql.g:338:1: functionCall : iriRef argList -> ^( FUNCTION iriRef ^( ARG_LIST argList ) ) ;
 10716  
     public final SparqlParser.functionCall_return functionCall() throws RecognitionException {
 10717  8
         SparqlParser.functionCall_return retval = new SparqlParser.functionCall_return();
 10718  8
         retval.start = input.LT(1);
 10719  
 
 10720  
 
 10721  8
         Object root_0 = null;
 10722  
 
 10723  8
         SparqlParser.iriRef_return iriRef241 =null;
 10724  
 
 10725  8
         SparqlParser.argList_return argList242 =null;
 10726  
 
 10727  
 
 10728  8
         RewriteRuleSubtreeStream stream_argList=new RewriteRuleSubtreeStream(adaptor,"rule argList");
 10729  8
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 10730  
         try {
 10731  
             // com\\googlecode\\sparkleg\\Sparql.g:339:5: ( iriRef argList -> ^( FUNCTION iriRef ^( ARG_LIST argList ) ) )
 10732  
             // com\\googlecode\\sparkleg\\Sparql.g:339:7: iriRef argList
 10733  
             {
 10734  8
             pushFollow(FOLLOW_iriRef_in_functionCall2765);
 10735  8
             iriRef241=iriRef();
 10736  
 
 10737  8
             state._fsp--;
 10738  
 
 10739  8
             stream_iriRef.add(iriRef241.getTree());
 10740  
 
 10741  8
             pushFollow(FOLLOW_argList_in_functionCall2767);
 10742  8
             argList242=argList();
 10743  
 
 10744  8
             state._fsp--;
 10745  
 
 10746  8
             stream_argList.add(argList242.getTree());
 10747  
 
 10748  
             // AST REWRITE
 10749  
             // elements: iriRef, argList
 10750  
             // token labels: 
 10751  
             // rule labels: retval
 10752  
             // token list labels: 
 10753  
             // rule list labels: 
 10754  
             // wildcard labels: 
 10755  8
             retval.tree = root_0;
 10756  8
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10757  
 
 10758  8
             root_0 = (Object)adaptor.nil();
 10759  
             // 339:22: -> ^( FUNCTION iriRef ^( ARG_LIST argList ) )
 10760  
             {
 10761  
                 // com\\googlecode\\sparkleg\\Sparql.g:339:25: ^( FUNCTION iriRef ^( ARG_LIST argList ) )
 10762  
                 {
 10763  8
                 Object root_1 = (Object)adaptor.nil();
 10764  8
                 root_1 = (Object)adaptor.becomeRoot(
 10765  
                 (Object)adaptor.create(FUNCTION, "FUNCTION")
 10766  
                 , root_1);
 10767  
 
 10768  8
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 10769  
 
 10770  
                 // com\\googlecode\\sparkleg\\Sparql.g:339:43: ^( ARG_LIST argList )
 10771  
                 {
 10772  8
                 Object root_2 = (Object)adaptor.nil();
 10773  8
                 root_2 = (Object)adaptor.becomeRoot(
 10774  
                 (Object)adaptor.create(ARG_LIST, "ARG_LIST")
 10775  
                 , root_2);
 10776  
 
 10777  8
                 adaptor.addChild(root_2, stream_argList.nextTree());
 10778  
 
 10779  8
                 adaptor.addChild(root_1, root_2);
 10780  
                 }
 10781  
 
 10782  8
                 adaptor.addChild(root_0, root_1);
 10783  
                 }
 10784  
 
 10785  
             }
 10786  
 
 10787  
 
 10788  8
             retval.tree = root_0;
 10789  
 
 10790  
             }
 10791  
 
 10792  8
             retval.stop = input.LT(-1);
 10793  
 
 10794  
 
 10795  8
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10796  8
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10797  
 
 10798  
         }
 10799  0
         catch (RecognitionException re) {
 10800  0
             reportError(re);
 10801  0
             recover(input,re);
 10802  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10803  
 
 10804  
         }
 10805  
 
 10806  0
         finally {
 10807  
                 // do for sure before leaving
 10808  8
         }
 10809  8
         return retval;
 10810  
     }
 10811  
     // $ANTLR end "functionCall"
 10812  
 
 10813  
 
 10814  56
     public static class argList_return extends ParserRuleReturnScope {
 10815  
         Object tree;
 10816  56
         public Object getTree() { return tree; }
 10817  
     };
 10818  
 
 10819  
 
 10820  
     // $ANTLR start "argList"
 10821  
     // com\\googlecode\\sparkleg\\Sparql.g:342:1: argList : ( nil -> nil | OPEN_BRACE ( DISTINCT )? expression ( COMMA expression )* CLOSE_BRACE -> ( DISTINCT )? ( expression )* );
 10822  
     public final SparqlParser.argList_return argList() throws RecognitionException {
 10823  56
         SparqlParser.argList_return retval = new SparqlParser.argList_return();
 10824  56
         retval.start = input.LT(1);
 10825  
 
 10826  
 
 10827  56
         Object root_0 = null;
 10828  
 
 10829  56
         Token OPEN_BRACE244=null;
 10830  56
         Token DISTINCT245=null;
 10831  56
         Token COMMA247=null;
 10832  56
         Token CLOSE_BRACE249=null;
 10833  56
         SparqlParser.nil_return nil243 =null;
 10834  
 
 10835  56
         SparqlParser.expression_return expression246 =null;
 10836  
 
 10837  56
         SparqlParser.expression_return expression248 =null;
 10838  
 
 10839  
 
 10840  56
         Object OPEN_BRACE244_tree=null;
 10841  56
         Object DISTINCT245_tree=null;
 10842  56
         Object COMMA247_tree=null;
 10843  56
         Object CLOSE_BRACE249_tree=null;
 10844  56
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 10845  56
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 10846  56
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 10847  56
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 10848  56
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 10849  56
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 10850  
         try {
 10851  
             // com\\googlecode\\sparkleg\\Sparql.g:343:5: ( nil -> nil | OPEN_BRACE ( DISTINCT )? expression ( COMMA expression )* CLOSE_BRACE -> ( DISTINCT )? ( expression )* )
 10852  56
             int alt79=2;
 10853  56
             switch ( input.LA(1) ) {
 10854  
             case OPEN_BRACE:
 10855  
                 {
 10856  56
                 switch ( input.LA(2) ) {
 10857  
                 case CLOSE_BRACE:
 10858  
                     {
 10859  6
                     alt79=1;
 10860  
                     }
 10861  6
                     break;
 10862  
                 case ABS:
 10863  
                 case AVG:
 10864  
                 case BNODE:
 10865  
                 case BOUND:
 10866  
                 case CEIL:
 10867  
                 case COALESCE:
 10868  
                 case CONCAT:
 10869  
                 case CONTAINS:
 10870  
                 case COUNT:
 10871  
                 case DATATYPE:
 10872  
                 case DAY:
 10873  
                 case DECIMAL:
 10874  
                 case DECIMAL_NEGATIVE:
 10875  
                 case DECIMAL_POSITIVE:
 10876  
                 case DISTINCT:
 10877  
                 case DOUBLE:
 10878  
                 case DOUBLE_NEGATIVE:
 10879  
                 case DOUBLE_POSITIVE:
 10880  
                 case ENCODE_FOR_URI:
 10881  
                 case EXISTS:
 10882  
                 case FALSE:
 10883  
                 case FLOOR:
 10884  
                 case GROUP_CONCAT:
 10885  
                 case HOURS:
 10886  
                 case IF:
 10887  
                 case INTEGER:
 10888  
                 case INTEGER_NEGATIVE:
 10889  
                 case INTEGER_POSITIVE:
 10890  
                 case IRI:
 10891  
                 case IRI_REF:
 10892  
                 case ISBLANK:
 10893  
                 case ISIRI:
 10894  
                 case ISLITERAL:
 10895  
                 case ISNUMERIC:
 10896  
                 case ISURI:
 10897  
                 case LANG:
 10898  
                 case LANGMATCHES:
 10899  
                 case LCASE:
 10900  
                 case MAX:
 10901  
                 case MD5:
 10902  
                 case MIN:
 10903  
                 case MINUS:
 10904  
                 case MINUTES:
 10905  
                 case MONTH:
 10906  
                 case NEGATION:
 10907  
                 case NOT:
 10908  
                 case NOW:
 10909  
                 case OPEN_BRACE:
 10910  
                 case PLUS:
 10911  
                 case PNAME_LN:
 10912  
                 case PNAME_NS:
 10913  
                 case RAND:
 10914  
                 case REGEX:
 10915  
                 case REPLACE:
 10916  
                 case ROUND:
 10917  
                 case SAMETERM:
 10918  
                 case SAMPLE:
 10919  
                 case SECONDS:
 10920  
                 case SHA1:
 10921  
                 case SHA224:
 10922  
                 case SHA256:
 10923  
                 case SHA384:
 10924  
                 case SHA512:
 10925  
                 case STR:
 10926  
                 case STRAFTER:
 10927  
                 case STRBEFORE:
 10928  
                 case STRDT:
 10929  
                 case STRENDS:
 10930  
                 case STRING_LITERAL1:
 10931  
                 case STRING_LITERAL2:
 10932  
                 case STRING_LITERAL_LONG1:
 10933  
                 case STRING_LITERAL_LONG2:
 10934  
                 case STRLANG:
 10935  
                 case STRLEN:
 10936  
                 case STRSTARTS:
 10937  
                 case SUBSTR:
 10938  
                 case SUM:
 10939  
                 case TIMEZONE:
 10940  
                 case TRUE:
 10941  
                 case TZ:
 10942  
                 case UCASE:
 10943  
                 case URI:
 10944  
                 case VAR1:
 10945  
                 case VAR2:
 10946  
                 case YEAR:
 10947  
                     {
 10948  50
                     alt79=2;
 10949  
                     }
 10950  50
                     break;
 10951  
                 default:
 10952  0
                     NoViableAltException nvae =
 10953  
                         new NoViableAltException("", 79, 1, input);
 10954  
 
 10955  0
                     throw nvae;
 10956  
 
 10957  
                 }
 10958  
 
 10959  
                 }
 10960  56
                 break;
 10961  
             default:
 10962  0
                 NoViableAltException nvae =
 10963  
                     new NoViableAltException("", 79, 0, input);
 10964  
 
 10965  0
                 throw nvae;
 10966  
 
 10967  
             }
 10968  
 
 10969  56
             switch (alt79) {
 10970  
                 case 1 :
 10971  
                     // com\\googlecode\\sparkleg\\Sparql.g:343:7: nil
 10972  
                     {
 10973  6
                     pushFollow(FOLLOW_nil_in_argList2798);
 10974  6
                     nil243=nil();
 10975  
 
 10976  6
                     state._fsp--;
 10977  
 
 10978  6
                     stream_nil.add(nil243.getTree());
 10979  
 
 10980  
                     // AST REWRITE
 10981  
                     // elements: nil
 10982  
                     // token labels: 
 10983  
                     // rule labels: retval
 10984  
                     // token list labels: 
 10985  
                     // rule list labels: 
 10986  
                     // wildcard labels: 
 10987  6
                     retval.tree = root_0;
 10988  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10989  
 
 10990  6
                     root_0 = (Object)adaptor.nil();
 10991  
                     // 343:11: -> nil
 10992  
                     {
 10993  6
                         adaptor.addChild(root_0, stream_nil.nextTree());
 10994  
 
 10995  
                     }
 10996  
 
 10997  
 
 10998  6
                     retval.tree = root_0;
 10999  
 
 11000  
                     }
 11001  6
                     break;
 11002  
                 case 2 :
 11003  
                     // com\\googlecode\\sparkleg\\Sparql.g:344:7: OPEN_BRACE ( DISTINCT )? expression ( COMMA expression )* CLOSE_BRACE
 11004  
                     {
 11005  50
                     OPEN_BRACE244=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_argList2810);  
 11006  50
                     stream_OPEN_BRACE.add(OPEN_BRACE244);
 11007  
 
 11008  
 
 11009  
                     // com\\googlecode\\sparkleg\\Sparql.g:344:18: ( DISTINCT )?
 11010  50
                     int alt77=2;
 11011  50
                     switch ( input.LA(1) ) {
 11012  
                         case DISTINCT:
 11013  
                             {
 11014  0
                             alt77=1;
 11015  
                             }
 11016  
                             break;
 11017  
                     }
 11018  
 
 11019  50
                     switch (alt77) {
 11020  
                         case 1 :
 11021  
                             // com\\googlecode\\sparkleg\\Sparql.g:344:18: DISTINCT
 11022  
                             {
 11023  0
                             DISTINCT245=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_argList2812);  
 11024  0
                             stream_DISTINCT.add(DISTINCT245);
 11025  
 
 11026  
 
 11027  
                             }
 11028  
                             break;
 11029  
 
 11030  
                     }
 11031  
 
 11032  
 
 11033  50
                     pushFollow(FOLLOW_expression_in_argList2815);
 11034  50
                     expression246=expression();
 11035  
 
 11036  50
                     state._fsp--;
 11037  
 
 11038  50
                     stream_expression.add(expression246.getTree());
 11039  
 
 11040  
                     // com\\googlecode\\sparkleg\\Sparql.g:344:39: ( COMMA expression )*
 11041  
                     loop78:
 11042  
                     do {
 11043  68
                         int alt78=2;
 11044  68
                         switch ( input.LA(1) ) {
 11045  
                         case COMMA:
 11046  
                             {
 11047  18
                             alt78=1;
 11048  
                             }
 11049  
                             break;
 11050  
 
 11051  
                         }
 11052  
 
 11053  68
                         switch (alt78) {
 11054  
                             case 1 :
 11055  
                                 // com\\googlecode\\sparkleg\\Sparql.g:344:40: COMMA expression
 11056  
                                 {
 11057  18
                                 COMMA247=(Token)match(input,COMMA,FOLLOW_COMMA_in_argList2818);  
 11058  18
                                 stream_COMMA.add(COMMA247);
 11059  
 
 11060  
 
 11061  18
                                 pushFollow(FOLLOW_expression_in_argList2820);
 11062  18
                                 expression248=expression();
 11063  
 
 11064  18
                                 state._fsp--;
 11065  
 
 11066  18
                                 stream_expression.add(expression248.getTree());
 11067  
 
 11068  
                                 }
 11069  18
                                 break;
 11070  
 
 11071  
                             default :
 11072  50
                                 break loop78;
 11073  
                         }
 11074  18
                     } while (true);
 11075  
 
 11076  
 
 11077  50
                     CLOSE_BRACE249=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_argList2824);  
 11078  50
                     stream_CLOSE_BRACE.add(CLOSE_BRACE249);
 11079  
 
 11080  
 
 11081  
                     // AST REWRITE
 11082  
                     // elements: expression, DISTINCT
 11083  
                     // token labels: 
 11084  
                     // rule labels: retval
 11085  
                     // token list labels: 
 11086  
                     // rule list labels: 
 11087  
                     // wildcard labels: 
 11088  50
                     retval.tree = root_0;
 11089  50
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11090  
 
 11091  50
                     root_0 = (Object)adaptor.nil();
 11092  
                     // 344:71: -> ( DISTINCT )? ( expression )*
 11093  
                     {
 11094  
                         // com\\googlecode\\sparkleg\\Sparql.g:344:74: ( DISTINCT )?
 11095  50
                         if ( stream_DISTINCT.hasNext() ) {
 11096  0
                             adaptor.addChild(root_0, 
 11097  
                             stream_DISTINCT.nextNode()
 11098  
                             );
 11099  
 
 11100  
                         }
 11101  50
                         stream_DISTINCT.reset();
 11102  
 
 11103  
                         // com\\googlecode\\sparkleg\\Sparql.g:344:84: ( expression )*
 11104  118
                         while ( stream_expression.hasNext() ) {
 11105  68
                             adaptor.addChild(root_0, stream_expression.nextTree());
 11106  
 
 11107  
                         }
 11108  50
                         stream_expression.reset();
 11109  
 
 11110  
                     }
 11111  
 
 11112  
 
 11113  50
                     retval.tree = root_0;
 11114  
 
 11115  
                     }
 11116  
                     break;
 11117  
 
 11118  
             }
 11119  56
             retval.stop = input.LT(-1);
 11120  
 
 11121  
 
 11122  56
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11123  56
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11124  
 
 11125  
         }
 11126  0
         catch (RecognitionException re) {
 11127  0
             reportError(re);
 11128  0
             recover(input,re);
 11129  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11130  
 
 11131  
         }
 11132  
 
 11133  0
         finally {
 11134  
                 // do for sure before leaving
 11135  56
         }
 11136  56
         return retval;
 11137  
     }
 11138  
     // $ANTLR end "argList"
 11139  
 
 11140  
 
 11141  30
     public static class expressionList_return extends ParserRuleReturnScope {
 11142  
         Object tree;
 11143  30
         public Object getTree() { return tree; }
 11144  
     };
 11145  
 
 11146  
 
 11147  
     // $ANTLR start "expressionList"
 11148  
     // com\\googlecode\\sparkleg\\Sparql.g:347:1: expressionList : ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE ) -> ^( EXPRESSION_LIST ( nil )* ( expression )* ) ;
 11149  
     public final SparqlParser.expressionList_return expressionList() throws RecognitionException {
 11150  30
         SparqlParser.expressionList_return retval = new SparqlParser.expressionList_return();
 11151  30
         retval.start = input.LT(1);
 11152  
 
 11153  
 
 11154  30
         Object root_0 = null;
 11155  
 
 11156  30
         Token OPEN_BRACE251=null;
 11157  30
         Token COMMA253=null;
 11158  30
         Token CLOSE_BRACE255=null;
 11159  30
         SparqlParser.nil_return nil250 =null;
 11160  
 
 11161  30
         SparqlParser.expression_return expression252 =null;
 11162  
 
 11163  30
         SparqlParser.expression_return expression254 =null;
 11164  
 
 11165  
 
 11166  30
         Object OPEN_BRACE251_tree=null;
 11167  30
         Object COMMA253_tree=null;
 11168  30
         Object CLOSE_BRACE255_tree=null;
 11169  30
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 11170  30
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 11171  30
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 11172  30
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 11173  30
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 11174  
         try {
 11175  
             // com\\googlecode\\sparkleg\\Sparql.g:348:5: ( ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE ) -> ^( EXPRESSION_LIST ( nil )* ( expression )* ) )
 11176  
             // com\\googlecode\\sparkleg\\Sparql.g:348:7: ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE )
 11177  
             {
 11178  
             // com\\googlecode\\sparkleg\\Sparql.g:348:7: ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE )
 11179  30
             int alt81=2;
 11180  30
             switch ( input.LA(1) ) {
 11181  
             case OPEN_BRACE:
 11182  
                 {
 11183  30
                 switch ( input.LA(2) ) {
 11184  
                 case CLOSE_BRACE:
 11185  
                     {
 11186  2
                     alt81=1;
 11187  
                     }
 11188  2
                     break;
 11189  
                 case ABS:
 11190  
                 case AVG:
 11191  
                 case BNODE:
 11192  
                 case BOUND:
 11193  
                 case CEIL:
 11194  
                 case COALESCE:
 11195  
                 case CONCAT:
 11196  
                 case CONTAINS:
 11197  
                 case COUNT:
 11198  
                 case DATATYPE:
 11199  
                 case DAY:
 11200  
                 case DECIMAL:
 11201  
                 case DECIMAL_NEGATIVE:
 11202  
                 case DECIMAL_POSITIVE:
 11203  
                 case DOUBLE:
 11204  
                 case DOUBLE_NEGATIVE:
 11205  
                 case DOUBLE_POSITIVE:
 11206  
                 case ENCODE_FOR_URI:
 11207  
                 case EXISTS:
 11208  
                 case FALSE:
 11209  
                 case FLOOR:
 11210  
                 case GROUP_CONCAT:
 11211  
                 case HOURS:
 11212  
                 case IF:
 11213  
                 case INTEGER:
 11214  
                 case INTEGER_NEGATIVE:
 11215  
                 case INTEGER_POSITIVE:
 11216  
                 case IRI:
 11217  
                 case IRI_REF:
 11218  
                 case ISBLANK:
 11219  
                 case ISIRI:
 11220  
                 case ISLITERAL:
 11221  
                 case ISNUMERIC:
 11222  
                 case ISURI:
 11223  
                 case LANG:
 11224  
                 case LANGMATCHES:
 11225  
                 case LCASE:
 11226  
                 case MAX:
 11227  
                 case MD5:
 11228  
                 case MIN:
 11229  
                 case MINUS:
 11230  
                 case MINUTES:
 11231  
                 case MONTH:
 11232  
                 case NEGATION:
 11233  
                 case NOT:
 11234  
                 case NOW:
 11235  
                 case OPEN_BRACE:
 11236  
                 case PLUS:
 11237  
                 case PNAME_LN:
 11238  
                 case PNAME_NS:
 11239  
                 case RAND:
 11240  
                 case REGEX:
 11241  
                 case REPLACE:
 11242  
                 case ROUND:
 11243  
                 case SAMETERM:
 11244  
                 case SAMPLE:
 11245  
                 case SECONDS:
 11246  
                 case SHA1:
 11247  
                 case SHA224:
 11248  
                 case SHA256:
 11249  
                 case SHA384:
 11250  
                 case SHA512:
 11251  
                 case STR:
 11252  
                 case STRAFTER:
 11253  
                 case STRBEFORE:
 11254  
                 case STRDT:
 11255  
                 case STRENDS:
 11256  
                 case STRING_LITERAL1:
 11257  
                 case STRING_LITERAL2:
 11258  
                 case STRING_LITERAL_LONG1:
 11259  
                 case STRING_LITERAL_LONG2:
 11260  
                 case STRLANG:
 11261  
                 case STRLEN:
 11262  
                 case STRSTARTS:
 11263  
                 case SUBSTR:
 11264  
                 case SUM:
 11265  
                 case TIMEZONE:
 11266  
                 case TRUE:
 11267  
                 case TZ:
 11268  
                 case UCASE:
 11269  
                 case URI:
 11270  
                 case VAR1:
 11271  
                 case VAR2:
 11272  
                 case YEAR:
 11273  
                     {
 11274  28
                     alt81=2;
 11275  
                     }
 11276  28
                     break;
 11277  
                 default:
 11278  0
                     NoViableAltException nvae =
 11279  
                         new NoViableAltException("", 81, 1, input);
 11280  
 
 11281  0
                     throw nvae;
 11282  
 
 11283  
                 }
 11284  
 
 11285  
                 }
 11286  30
                 break;
 11287  
             default:
 11288  0
                 NoViableAltException nvae =
 11289  
                     new NoViableAltException("", 81, 0, input);
 11290  
 
 11291  0
                 throw nvae;
 11292  
 
 11293  
             }
 11294  
 
 11295  30
             switch (alt81) {
 11296  
                 case 1 :
 11297  
                     // com\\googlecode\\sparkleg\\Sparql.g:348:8: nil
 11298  
                     {
 11299  2
                     pushFollow(FOLLOW_nil_in_expressionList2850);
 11300  2
                     nil250=nil();
 11301  
 
 11302  2
                     state._fsp--;
 11303  
 
 11304  2
                     stream_nil.add(nil250.getTree());
 11305  
 
 11306  
                     }
 11307  2
                     break;
 11308  
                 case 2 :
 11309  
                     // com\\googlecode\\sparkleg\\Sparql.g:348:14: OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE
 11310  
                     {
 11311  28
                     OPEN_BRACE251=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_expressionList2854);  
 11312  28
                     stream_OPEN_BRACE.add(OPEN_BRACE251);
 11313  
 
 11314  
 
 11315  28
                     pushFollow(FOLLOW_expression_in_expressionList2856);
 11316  28
                     expression252=expression();
 11317  
 
 11318  28
                     state._fsp--;
 11319  
 
 11320  28
                     stream_expression.add(expression252.getTree());
 11321  
 
 11322  
                     // com\\googlecode\\sparkleg\\Sparql.g:348:36: ( COMMA expression )*
 11323  
                     loop80:
 11324  
                     do {
 11325  62
                         int alt80=2;
 11326  62
                         switch ( input.LA(1) ) {
 11327  
                         case COMMA:
 11328  
                             {
 11329  34
                             alt80=1;
 11330  
                             }
 11331  
                             break;
 11332  
 
 11333  
                         }
 11334  
 
 11335  62
                         switch (alt80) {
 11336  
                             case 1 :
 11337  
                                 // com\\googlecode\\sparkleg\\Sparql.g:348:37: COMMA expression
 11338  
                                 {
 11339  34
                                 COMMA253=(Token)match(input,COMMA,FOLLOW_COMMA_in_expressionList2859);  
 11340  34
                                 stream_COMMA.add(COMMA253);
 11341  
 
 11342  
 
 11343  34
                                 pushFollow(FOLLOW_expression_in_expressionList2861);
 11344  34
                                 expression254=expression();
 11345  
 
 11346  34
                                 state._fsp--;
 11347  
 
 11348  34
                                 stream_expression.add(expression254.getTree());
 11349  
 
 11350  
                                 }
 11351  34
                                 break;
 11352  
 
 11353  
                             default :
 11354  28
                                 break loop80;
 11355  
                         }
 11356  34
                     } while (true);
 11357  
 
 11358  
 
 11359  28
                     CLOSE_BRACE255=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_expressionList2865);  
 11360  28
                     stream_CLOSE_BRACE.add(CLOSE_BRACE255);
 11361  
 
 11362  
 
 11363  
                     }
 11364  
                     break;
 11365  
 
 11366  
             }
 11367  
 
 11368  
 
 11369  
             // AST REWRITE
 11370  
             // elements: nil, expression
 11371  
             // token labels: 
 11372  
             // rule labels: retval
 11373  
             // token list labels: 
 11374  
             // rule list labels: 
 11375  
             // wildcard labels: 
 11376  30
             retval.tree = root_0;
 11377  30
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11378  
 
 11379  30
             root_0 = (Object)adaptor.nil();
 11380  
             // 348:69: -> ^( EXPRESSION_LIST ( nil )* ( expression )* )
 11381  
             {
 11382  
                 // com\\googlecode\\sparkleg\\Sparql.g:348:72: ^( EXPRESSION_LIST ( nil )* ( expression )* )
 11383  
                 {
 11384  30
                 Object root_1 = (Object)adaptor.nil();
 11385  30
                 root_1 = (Object)adaptor.becomeRoot(
 11386  
                 (Object)adaptor.create(EXPRESSION_LIST, "EXPRESSION_LIST")
 11387  
                 , root_1);
 11388  
 
 11389  
                 // com\\googlecode\\sparkleg\\Sparql.g:348:90: ( nil )*
 11390  32
                 while ( stream_nil.hasNext() ) {
 11391  2
                     adaptor.addChild(root_1, stream_nil.nextTree());
 11392  
 
 11393  
                 }
 11394  30
                 stream_nil.reset();
 11395  
 
 11396  
                 // com\\googlecode\\sparkleg\\Sparql.g:348:95: ( expression )*
 11397  92
                 while ( stream_expression.hasNext() ) {
 11398  62
                     adaptor.addChild(root_1, stream_expression.nextTree());
 11399  
 
 11400  
                 }
 11401  30
                 stream_expression.reset();
 11402  
 
 11403  30
                 adaptor.addChild(root_0, root_1);
 11404  
                 }
 11405  
 
 11406  
             }
 11407  
 
 11408  
 
 11409  30
             retval.tree = root_0;
 11410  
 
 11411  
             }
 11412  
 
 11413  30
             retval.stop = input.LT(-1);
 11414  
 
 11415  
 
 11416  30
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11417  30
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11418  
 
 11419  
         }
 11420  0
         catch (RecognitionException re) {
 11421  0
             reportError(re);
 11422  0
             recover(input,re);
 11423  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11424  
 
 11425  
         }
 11426  
 
 11427  0
         finally {
 11428  
                 // do for sure before leaving
 11429  30
         }
 11430  30
         return retval;
 11431  
     }
 11432  
     // $ANTLR end "expressionList"
 11433  
 
 11434  
 
 11435  54
     public static class constructTemplate_return extends ParserRuleReturnScope {
 11436  
         Object tree;
 11437  54
         public Object getTree() { return tree; }
 11438  
     };
 11439  
 
 11440  
 
 11441  
     // $ANTLR start "constructTemplate"
 11442  
     // com\\googlecode\\sparkleg\\Sparql.g:351:1: constructTemplate : OPEN_CURLY_BRACE ( constructTriples )? CLOSE_CURLY_BRACE -> ^( CONSTRUCT_TRIPLES ( constructTriples )? ) ;
 11443  
     public final SparqlParser.constructTemplate_return constructTemplate() throws RecognitionException {
 11444  54
         SparqlParser.constructTemplate_return retval = new SparqlParser.constructTemplate_return();
 11445  54
         retval.start = input.LT(1);
 11446  
 
 11447  
 
 11448  54
         Object root_0 = null;
 11449  
 
 11450  54
         Token OPEN_CURLY_BRACE256=null;
 11451  54
         Token CLOSE_CURLY_BRACE258=null;
 11452  54
         SparqlParser.constructTriples_return constructTriples257 =null;
 11453  
 
 11454  
 
 11455  54
         Object OPEN_CURLY_BRACE256_tree=null;
 11456  54
         Object CLOSE_CURLY_BRACE258_tree=null;
 11457  54
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 11458  54
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 11459  54
         RewriteRuleSubtreeStream stream_constructTriples=new RewriteRuleSubtreeStream(adaptor,"rule constructTriples");
 11460  
         try {
 11461  
             // com\\googlecode\\sparkleg\\Sparql.g:352:5: ( OPEN_CURLY_BRACE ( constructTriples )? CLOSE_CURLY_BRACE -> ^( CONSTRUCT_TRIPLES ( constructTriples )? ) )
 11462  
             // com\\googlecode\\sparkleg\\Sparql.g:352:7: OPEN_CURLY_BRACE ( constructTriples )? CLOSE_CURLY_BRACE
 11463  
             {
 11464  54
             OPEN_CURLY_BRACE256=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_constructTemplate2896);  
 11465  54
             stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE256);
 11466  
 
 11467  
 
 11468  
             // com\\googlecode\\sparkleg\\Sparql.g:352:24: ( constructTriples )?
 11469  54
             int alt82=2;
 11470  54
             switch ( input.LA(1) ) {
 11471  
                 case BLANK_NODE_LABEL:
 11472  
                 case DECIMAL:
 11473  
                 case DECIMAL_NEGATIVE:
 11474  
                 case DECIMAL_POSITIVE:
 11475  
                 case DOUBLE:
 11476  
                 case DOUBLE_NEGATIVE:
 11477  
                 case DOUBLE_POSITIVE:
 11478  
                 case FALSE:
 11479  
                 case INTEGER:
 11480  
                 case INTEGER_NEGATIVE:
 11481  
                 case INTEGER_POSITIVE:
 11482  
                 case IRI_REF:
 11483  
                 case OPEN_BRACE:
 11484  
                 case OPEN_SQUARE_BRACKET:
 11485  
                 case PNAME_LN:
 11486  
                 case PNAME_NS:
 11487  
                 case STRING_LITERAL1:
 11488  
                 case STRING_LITERAL2:
 11489  
                 case STRING_LITERAL_LONG1:
 11490  
                 case STRING_LITERAL_LONG2:
 11491  
                 case TRUE:
 11492  
                 case VAR1:
 11493  
                 case VAR2:
 11494  
                     {
 11495  52
                     alt82=1;
 11496  
                     }
 11497  
                     break;
 11498  
             }
 11499  
 
 11500  54
             switch (alt82) {
 11501  
                 case 1 :
 11502  
                     // com\\googlecode\\sparkleg\\Sparql.g:352:24: constructTriples
 11503  
                     {
 11504  52
                     pushFollow(FOLLOW_constructTriples_in_constructTemplate2898);
 11505  52
                     constructTriples257=constructTriples();
 11506  
 
 11507  52
                     state._fsp--;
 11508  
 
 11509  52
                     stream_constructTriples.add(constructTriples257.getTree());
 11510  
 
 11511  
                     }
 11512  
                     break;
 11513  
 
 11514  
             }
 11515  
 
 11516  
 
 11517  54
             CLOSE_CURLY_BRACE258=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_constructTemplate2901);  
 11518  54
             stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE258);
 11519  
 
 11520  
 
 11521  
             // AST REWRITE
 11522  
             // elements: constructTriples
 11523  
             // token labels: 
 11524  
             // rule labels: retval
 11525  
             // token list labels: 
 11526  
             // rule list labels: 
 11527  
             // wildcard labels: 
 11528  54
             retval.tree = root_0;
 11529  54
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11530  
 
 11531  54
             root_0 = (Object)adaptor.nil();
 11532  
             // 352:60: -> ^( CONSTRUCT_TRIPLES ( constructTriples )? )
 11533  
             {
 11534  
                 // com\\googlecode\\sparkleg\\Sparql.g:352:63: ^( CONSTRUCT_TRIPLES ( constructTriples )? )
 11535  
                 {
 11536  54
                 Object root_1 = (Object)adaptor.nil();
 11537  54
                 root_1 = (Object)adaptor.becomeRoot(
 11538  
                 (Object)adaptor.create(CONSTRUCT_TRIPLES, "CONSTRUCT_TRIPLES")
 11539  
                 , root_1);
 11540  
 
 11541  
                 // com\\googlecode\\sparkleg\\Sparql.g:352:83: ( constructTriples )?
 11542  54
                 if ( stream_constructTriples.hasNext() ) {
 11543  52
                     adaptor.addChild(root_1, stream_constructTriples.nextTree());
 11544  
 
 11545  
                 }
 11546  54
                 stream_constructTriples.reset();
 11547  
 
 11548  54
                 adaptor.addChild(root_0, root_1);
 11549  
                 }
 11550  
 
 11551  
             }
 11552  
 
 11553  
 
 11554  54
             retval.tree = root_0;
 11555  
 
 11556  
             }
 11557  
 
 11558  54
             retval.stop = input.LT(-1);
 11559  
 
 11560  
 
 11561  54
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11562  54
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11563  
 
 11564  
         }
 11565  0
         catch (RecognitionException re) {
 11566  0
             reportError(re);
 11567  0
             recover(input,re);
 11568  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11569  
 
 11570  
         }
 11571  
 
 11572  0
         finally {
 11573  
                 // do for sure before leaving
 11574  54
         }
 11575  54
         return retval;
 11576  
     }
 11577  
     // $ANTLR end "constructTemplate"
 11578  
 
 11579  
 
 11580  52
     public static class constructTriples_return extends ParserRuleReturnScope {
 11581  
         Object tree;
 11582  52
         public Object getTree() { return tree; }
 11583  
     };
 11584  
 
 11585  
 
 11586  
     // $ANTLR start "constructTriples"
 11587  
     // com\\googlecode\\sparkleg\\Sparql.g:355:1: constructTriples : triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ( triplesSameSubject )+ ;
 11588  
     public final SparqlParser.constructTriples_return constructTriples() throws RecognitionException {
 11589  52
         SparqlParser.constructTriples_return retval = new SparqlParser.constructTriples_return();
 11590  52
         retval.start = input.LT(1);
 11591  
 
 11592  
 
 11593  52
         Object root_0 = null;
 11594  
 
 11595  52
         Token DOT260=null;
 11596  52
         Token DOT262=null;
 11597  52
         SparqlParser.triplesSameSubject_return triplesSameSubject259 =null;
 11598  
 
 11599  52
         SparqlParser.triplesSameSubject_return triplesSameSubject261 =null;
 11600  
 
 11601  
 
 11602  52
         Object DOT260_tree=null;
 11603  52
         Object DOT262_tree=null;
 11604  52
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 11605  52
         RewriteRuleSubtreeStream stream_triplesSameSubject=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubject");
 11606  
         try {
 11607  
             // com\\googlecode\\sparkleg\\Sparql.g:356:5: ( triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ( triplesSameSubject )+ )
 11608  
             // com\\googlecode\\sparkleg\\Sparql.g:356:7: triplesSameSubject ( DOT triplesSameSubject )* ( DOT )?
 11609  
             {
 11610  52
             pushFollow(FOLLOW_triplesSameSubject_in_constructTriples2927);
 11611  52
             triplesSameSubject259=triplesSameSubject();
 11612  
 
 11613  52
             state._fsp--;
 11614  
 
 11615  52
             stream_triplesSameSubject.add(triplesSameSubject259.getTree());
 11616  
 
 11617  
             // com\\googlecode\\sparkleg\\Sparql.g:356:26: ( DOT triplesSameSubject )*
 11618  
             loop83:
 11619  
             do {
 11620  68
                 int alt83=2;
 11621  68
                 switch ( input.LA(1) ) {
 11622  
                 case DOT:
 11623  
                     {
 11624  30
                     switch ( input.LA(2) ) {
 11625  
                     case BLANK_NODE_LABEL:
 11626  
                     case DECIMAL:
 11627  
                     case DECIMAL_NEGATIVE:
 11628  
                     case DECIMAL_POSITIVE:
 11629  
                     case DOUBLE:
 11630  
                     case DOUBLE_NEGATIVE:
 11631  
                     case DOUBLE_POSITIVE:
 11632  
                     case FALSE:
 11633  
                     case INTEGER:
 11634  
                     case INTEGER_NEGATIVE:
 11635  
                     case INTEGER_POSITIVE:
 11636  
                     case IRI_REF:
 11637  
                     case OPEN_BRACE:
 11638  
                     case OPEN_SQUARE_BRACKET:
 11639  
                     case PNAME_LN:
 11640  
                     case PNAME_NS:
 11641  
                     case STRING_LITERAL1:
 11642  
                     case STRING_LITERAL2:
 11643  
                     case STRING_LITERAL_LONG1:
 11644  
                     case STRING_LITERAL_LONG2:
 11645  
                     case TRUE:
 11646  
                     case VAR1:
 11647  
                     case VAR2:
 11648  
                         {
 11649  16
                         alt83=1;
 11650  
                         }
 11651  
                         break;
 11652  
 
 11653  
                     }
 11654  
 
 11655  
                     }
 11656  
                     break;
 11657  
 
 11658  
                 }
 11659  
 
 11660  68
                 switch (alt83) {
 11661  
                     case 1 :
 11662  
                         // com\\googlecode\\sparkleg\\Sparql.g:356:27: DOT triplesSameSubject
 11663  
                         {
 11664  16
                         DOT260=(Token)match(input,DOT,FOLLOW_DOT_in_constructTriples2930);  
 11665  16
                         stream_DOT.add(DOT260);
 11666  
 
 11667  
 
 11668  16
                         pushFollow(FOLLOW_triplesSameSubject_in_constructTriples2932);
 11669  16
                         triplesSameSubject261=triplesSameSubject();
 11670  
 
 11671  16
                         state._fsp--;
 11672  
 
 11673  16
                         stream_triplesSameSubject.add(triplesSameSubject261.getTree());
 11674  
 
 11675  
                         }
 11676  16
                         break;
 11677  
 
 11678  
                     default :
 11679  52
                         break loop83;
 11680  
                 }
 11681  16
             } while (true);
 11682  
 
 11683  
 
 11684  
             // com\\googlecode\\sparkleg\\Sparql.g:356:52: ( DOT )?
 11685  52
             int alt84=2;
 11686  52
             switch ( input.LA(1) ) {
 11687  
                 case DOT:
 11688  
                     {
 11689  14
                     alt84=1;
 11690  
                     }
 11691  
                     break;
 11692  
             }
 11693  
 
 11694  52
             switch (alt84) {
 11695  
                 case 1 :
 11696  
                     // com\\googlecode\\sparkleg\\Sparql.g:356:52: DOT
 11697  
                     {
 11698  14
                     DOT262=(Token)match(input,DOT,FOLLOW_DOT_in_constructTriples2936);  
 11699  14
                     stream_DOT.add(DOT262);
 11700  
 
 11701  
 
 11702  
                     }
 11703  
                     break;
 11704  
 
 11705  
             }
 11706  
 
 11707  
 
 11708  
             // AST REWRITE
 11709  
             // elements: triplesSameSubject
 11710  
             // token labels: 
 11711  
             // rule labels: retval
 11712  
             // token list labels: 
 11713  
             // rule list labels: 
 11714  
             // wildcard labels: 
 11715  52
             retval.tree = root_0;
 11716  52
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11717  
 
 11718  52
             root_0 = (Object)adaptor.nil();
 11719  
             // 356:57: -> ( triplesSameSubject )+
 11720  
             {
 11721  52
                 if ( !(stream_triplesSameSubject.hasNext()) ) {
 11722  0
                     throw new RewriteEarlyExitException();
 11723  
                 }
 11724  120
                 while ( stream_triplesSameSubject.hasNext() ) {
 11725  68
                     adaptor.addChild(root_0, stream_triplesSameSubject.nextTree());
 11726  
 
 11727  
                 }
 11728  52
                 stream_triplesSameSubject.reset();
 11729  
 
 11730  
             }
 11731  
 
 11732  
 
 11733  52
             retval.tree = root_0;
 11734  
 
 11735  
             }
 11736  
 
 11737  52
             retval.stop = input.LT(-1);
 11738  
 
 11739  
 
 11740  52
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11741  52
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11742  
 
 11743  
         }
 11744  0
         catch (RecognitionException re) {
 11745  0
             reportError(re);
 11746  0
             recover(input,re);
 11747  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11748  
 
 11749  
         }
 11750  
 
 11751  0
         finally {
 11752  
                 // do for sure before leaving
 11753  52
         }
 11754  52
         return retval;
 11755  
     }
 11756  
     // $ANTLR end "constructTriples"
 11757  
 
 11758  
 
 11759  194
     public static class triplesSameSubject_return extends ParserRuleReturnScope {
 11760  
         Object tree;
 11761  194
         public Object getTree() { return tree; }
 11762  
     };
 11763  
 
 11764  
 
 11765  
     // $ANTLR start "triplesSameSubject"
 11766  
     // com\\googlecode\\sparkleg\\Sparql.g:359:1: triplesSameSubject : ( varOrTerm ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 11767  
     public final SparqlParser.triplesSameSubject_return triplesSameSubject() throws RecognitionException {
 11768  194
         SparqlParser.triplesSameSubject_return retval = new SparqlParser.triplesSameSubject_return();
 11769  194
         retval.start = input.LT(1);
 11770  
 
 11771  
 
 11772  194
         Object root_0 = null;
 11773  
 
 11774  194
         SparqlParser.varOrTerm_return varOrTerm263 =null;
 11775  
 
 11776  194
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty264 =null;
 11777  
 
 11778  194
         SparqlParser.triplesNode_return triplesNode265 =null;
 11779  
 
 11780  194
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty266 =null;
 11781  
 
 11782  
 
 11783  194
         RewriteRuleSubtreeStream stream_varOrTerm=new RewriteRuleSubtreeStream(adaptor,"rule varOrTerm");
 11784  194
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 11785  194
         RewriteRuleSubtreeStream stream_triplesNode=new RewriteRuleSubtreeStream(adaptor,"rule triplesNode");
 11786  
         try {
 11787  
             // com\\googlecode\\sparkleg\\Sparql.g:360:5: ( varOrTerm ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 11788  194
             int alt87=2;
 11789  194
             switch ( input.LA(1) ) {
 11790  
             case BLANK_NODE_LABEL:
 11791  
             case DECIMAL:
 11792  
             case DECIMAL_NEGATIVE:
 11793  
             case DECIMAL_POSITIVE:
 11794  
             case DOUBLE:
 11795  
             case DOUBLE_NEGATIVE:
 11796  
             case DOUBLE_POSITIVE:
 11797  
             case FALSE:
 11798  
             case INTEGER:
 11799  
             case INTEGER_NEGATIVE:
 11800  
             case INTEGER_POSITIVE:
 11801  
             case IRI_REF:
 11802  
             case PNAME_LN:
 11803  
             case PNAME_NS:
 11804  
             case STRING_LITERAL1:
 11805  
             case STRING_LITERAL2:
 11806  
             case STRING_LITERAL_LONG1:
 11807  
             case STRING_LITERAL_LONG2:
 11808  
             case TRUE:
 11809  
             case VAR1:
 11810  
             case VAR2:
 11811  
                 {
 11812  182
                 alt87=1;
 11813  
                 }
 11814  182
                 break;
 11815  
             case OPEN_SQUARE_BRACKET:
 11816  
                 {
 11817  12
                 switch ( input.LA(2) ) {
 11818  
                 case CLOSE_SQUARE_BRACKET:
 11819  
                     {
 11820  10
                     alt87=1;
 11821  
                     }
 11822  10
                     break;
 11823  
                 case A:
 11824  
                 case INVERSE:
 11825  
                 case IRI_REF:
 11826  
                 case NEGATION:
 11827  
                 case OPEN_BRACE:
 11828  
                 case PNAME_LN:
 11829  
                 case PNAME_NS:
 11830  
                 case VAR1:
 11831  
                 case VAR2:
 11832  
                     {
 11833  2
                     alt87=2;
 11834  
                     }
 11835  2
                     break;
 11836  
                 default:
 11837  0
                     NoViableAltException nvae =
 11838  
                         new NoViableAltException("", 87, 2, input);
 11839  
 
 11840  0
                     throw nvae;
 11841  
 
 11842  
                 }
 11843  
 
 11844  
                 }
 11845  12
                 break;
 11846  
             case OPEN_BRACE:
 11847  
                 {
 11848  0
                 switch ( input.LA(2) ) {
 11849  
                 case CLOSE_BRACE:
 11850  
                     {
 11851  0
                     alt87=1;
 11852  
                     }
 11853  0
                     break;
 11854  
                 case BLANK_NODE_LABEL:
 11855  
                 case DECIMAL:
 11856  
                 case DECIMAL_NEGATIVE:
 11857  
                 case DECIMAL_POSITIVE:
 11858  
                 case DOUBLE:
 11859  
                 case DOUBLE_NEGATIVE:
 11860  
                 case DOUBLE_POSITIVE:
 11861  
                 case FALSE:
 11862  
                 case INTEGER:
 11863  
                 case INTEGER_NEGATIVE:
 11864  
                 case INTEGER_POSITIVE:
 11865  
                 case IRI_REF:
 11866  
                 case OPEN_BRACE:
 11867  
                 case OPEN_SQUARE_BRACKET:
 11868  
                 case PNAME_LN:
 11869  
                 case PNAME_NS:
 11870  
                 case STRING_LITERAL1:
 11871  
                 case STRING_LITERAL2:
 11872  
                 case STRING_LITERAL_LONG1:
 11873  
                 case STRING_LITERAL_LONG2:
 11874  
                 case TRUE:
 11875  
                 case VAR1:
 11876  
                 case VAR2:
 11877  
                     {
 11878  0
                     alt87=2;
 11879  
                     }
 11880  0
                     break;
 11881  
                 default:
 11882  0
                     NoViableAltException nvae =
 11883  
                         new NoViableAltException("", 87, 3, input);
 11884  
 
 11885  0
                     throw nvae;
 11886  
 
 11887  
                 }
 11888  
 
 11889  
                 }
 11890  0
                 break;
 11891  
             default:
 11892  0
                 NoViableAltException nvae =
 11893  
                     new NoViableAltException("", 87, 0, input);
 11894  
 
 11895  0
                 throw nvae;
 11896  
 
 11897  
             }
 11898  
 
 11899  194
             switch (alt87) {
 11900  
                 case 1 :
 11901  
                     // com\\googlecode\\sparkleg\\Sparql.g:360:7: varOrTerm ( propertyListNotEmpty )?
 11902  
                     {
 11903  192
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubject2959);
 11904  192
                     varOrTerm263=varOrTerm();
 11905  
 
 11906  192
                     state._fsp--;
 11907  
 
 11908  192
                     stream_varOrTerm.add(varOrTerm263.getTree());
 11909  
 
 11910  
                     // com\\googlecode\\sparkleg\\Sparql.g:360:17: ( propertyListNotEmpty )?
 11911  192
                     int alt85=2;
 11912  192
                     switch ( input.LA(1) ) {
 11913  
                         case A:
 11914  
                         case INVERSE:
 11915  
                         case IRI_REF:
 11916  
                         case NEGATION:
 11917  
                         case OPEN_BRACE:
 11918  
                         case PNAME_LN:
 11919  
                         case PNAME_NS:
 11920  
                         case VAR1:
 11921  
                         case VAR2:
 11922  
                             {
 11923  192
                             alt85=1;
 11924  
                             }
 11925  
                             break;
 11926  
                     }
 11927  
 
 11928  192
                     switch (alt85) {
 11929  
                         case 1 :
 11930  
                             // com\\googlecode\\sparkleg\\Sparql.g:360:17: propertyListNotEmpty
 11931  
                             {
 11932  192
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject2961);
 11933  192
                             propertyListNotEmpty264=propertyListNotEmpty();
 11934  
 
 11935  192
                             state._fsp--;
 11936  
 
 11937  192
                             stream_propertyListNotEmpty.add(propertyListNotEmpty264.getTree());
 11938  
 
 11939  
                             }
 11940  
                             break;
 11941  
 
 11942  
                     }
 11943  
 
 11944  
 
 11945  
                     // AST REWRITE
 11946  
                     // elements: propertyListNotEmpty, varOrTerm
 11947  
                     // token labels: 
 11948  
                     // rule labels: retval
 11949  
                     // token list labels: 
 11950  
                     // rule list labels: 
 11951  
                     // wildcard labels: 
 11952  192
                     retval.tree = root_0;
 11953  192
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11954  
 
 11955  192
                     root_0 = (Object)adaptor.nil();
 11956  
                     // 360:39: -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? )
 11957  
                     {
 11958  
                         // com\\googlecode\\sparkleg\\Sparql.g:360:42: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? )
 11959  
                         {
 11960  192
                         Object root_1 = (Object)adaptor.nil();
 11961  192
                         root_1 = (Object)adaptor.becomeRoot(
 11962  
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 11963  
                         , root_1);
 11964  
 
 11965  
                         // com\\googlecode\\sparkleg\\Sparql.g:360:65: ^( SUBJECT varOrTerm )
 11966  
                         {
 11967  192
                         Object root_2 = (Object)adaptor.nil();
 11968  192
                         root_2 = (Object)adaptor.becomeRoot(
 11969  
                         (Object)adaptor.create(SUBJECT, "SUBJECT")
 11970  
                         , root_2);
 11971  
 
 11972  192
                         adaptor.addChild(root_2, stream_varOrTerm.nextTree());
 11973  
 
 11974  192
                         adaptor.addChild(root_1, root_2);
 11975  
                         }
 11976  
 
 11977  
                         // com\\googlecode\\sparkleg\\Sparql.g:360:86: ( propertyListNotEmpty )?
 11978  192
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 11979  192
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 11980  
 
 11981  
                         }
 11982  192
                         stream_propertyListNotEmpty.reset();
 11983  
 
 11984  192
                         adaptor.addChild(root_0, root_1);
 11985  
                         }
 11986  
 
 11987  
                     }
 11988  
 
 11989  
 
 11990  192
                     retval.tree = root_0;
 11991  
 
 11992  
                     }
 11993  192
                     break;
 11994  
                 case 2 :
 11995  
                     // com\\googlecode\\sparkleg\\Sparql.g:361:7: triplesNode ( propertyListNotEmpty )?
 11996  
                     {
 11997  2
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubject2985);
 11998  2
                     triplesNode265=triplesNode();
 11999  
 
 12000  2
                     state._fsp--;
 12001  
 
 12002  2
                     stream_triplesNode.add(triplesNode265.getTree());
 12003  
 
 12004  
                     // com\\googlecode\\sparkleg\\Sparql.g:361:19: ( propertyListNotEmpty )?
 12005  2
                     int alt86=2;
 12006  2
                     switch ( input.LA(1) ) {
 12007  
                         case A:
 12008  
                         case INVERSE:
 12009  
                         case IRI_REF:
 12010  
                         case NEGATION:
 12011  
                         case OPEN_BRACE:
 12012  
                         case PNAME_LN:
 12013  
                         case PNAME_NS:
 12014  
                         case VAR1:
 12015  
                         case VAR2:
 12016  
                             {
 12017  0
                             alt86=1;
 12018  
                             }
 12019  
                             break;
 12020  
                     }
 12021  
 
 12022  2
                     switch (alt86) {
 12023  
                         case 1 :
 12024  
                             // com\\googlecode\\sparkleg\\Sparql.g:361:19: propertyListNotEmpty
 12025  
                             {
 12026  0
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject2987);
 12027  0
                             propertyListNotEmpty266=propertyListNotEmpty();
 12028  
 
 12029  0
                             state._fsp--;
 12030  
 
 12031  0
                             stream_propertyListNotEmpty.add(propertyListNotEmpty266.getTree());
 12032  
 
 12033  
                             }
 12034  
                             break;
 12035  
 
 12036  
                     }
 12037  
 
 12038  
 
 12039  
                     // AST REWRITE
 12040  
                     // elements: propertyListNotEmpty, triplesNode
 12041  
                     // token labels: 
 12042  
                     // rule labels: retval
 12043  
                     // token list labels: 
 12044  
                     // rule list labels: 
 12045  
                     // wildcard labels: 
 12046  2
                     retval.tree = root_0;
 12047  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12048  
 
 12049  2
                     root_0 = (Object)adaptor.nil();
 12050  
                     // 361:41: -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12051  
                     {
 12052  
                         // com\\googlecode\\sparkleg\\Sparql.g:361:44: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12053  
                         {
 12054  2
                         Object root_1 = (Object)adaptor.nil();
 12055  2
                         root_1 = (Object)adaptor.becomeRoot(
 12056  
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12057  
                         , root_1);
 12058  
 
 12059  2
                         adaptor.addChild(root_1, stream_triplesNode.nextTree());
 12060  
 
 12061  
                         // com\\googlecode\\sparkleg\\Sparql.g:361:79: ( propertyListNotEmpty )?
 12062  2
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12063  0
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12064  
 
 12065  
                         }
 12066  2
                         stream_propertyListNotEmpty.reset();
 12067  
 
 12068  2
                         adaptor.addChild(root_0, root_1);
 12069  
                         }
 12070  
 
 12071  
                     }
 12072  
 
 12073  
 
 12074  2
                     retval.tree = root_0;
 12075  
 
 12076  
                     }
 12077  
                     break;
 12078  
 
 12079  
             }
 12080  194
             retval.stop = input.LT(-1);
 12081  
 
 12082  
 
 12083  194
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12084  194
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12085  
 
 12086  
         }
 12087  0
         catch (RecognitionException re) {
 12088  0
             reportError(re);
 12089  0
             recover(input,re);
 12090  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12091  
 
 12092  
         }
 12093  
 
 12094  0
         finally {
 12095  
                 // do for sure before leaving
 12096  194
         }
 12097  194
         return retval;
 12098  
     }
 12099  
     // $ANTLR end "triplesSameSubject"
 12100  
 
 12101  
 
 12102  230
     public static class propertyListNotEmpty_return extends ParserRuleReturnScope {
 12103  
         Object tree;
 12104  230
         public Object getTree() { return tree; }
 12105  
     };
 12106  
 
 12107  
 
 12108  
     // $ANTLR start "propertyListNotEmpty"
 12109  
     // com\\googlecode\\sparkleg\\Sparql.g:364:1: propertyListNotEmpty : propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ ;
 12110  
     public final SparqlParser.propertyListNotEmpty_return propertyListNotEmpty() throws RecognitionException {
 12111  230
         SparqlParser.propertyListNotEmpty_return retval = new SparqlParser.propertyListNotEmpty_return();
 12112  230
         retval.start = input.LT(1);
 12113  
 
 12114  
 
 12115  230
         Object root_0 = null;
 12116  
 
 12117  230
         Token SEMICOLON268=null;
 12118  230
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails267 =null;
 12119  
 
 12120  230
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails269 =null;
 12121  
 
 12122  
 
 12123  230
         Object SEMICOLON268_tree=null;
 12124  230
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 12125  230
         RewriteRuleSubtreeStream stream_propertyListNotEmptyDetails=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyDetails");
 12126  
         try {
 12127  
             // com\\googlecode\\sparkleg\\Sparql.g:365:5: ( propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ )
 12128  
             // com\\googlecode\\sparkleg\\Sparql.g:365:7: propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12129  
             {
 12130  230
             pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3017);
 12131  230
             propertyListNotEmptyDetails267=propertyListNotEmptyDetails();
 12132  
 
 12133  230
             state._fsp--;
 12134  
 
 12135  230
             stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails267.getTree());
 12136  
 
 12137  
             // com\\googlecode\\sparkleg\\Sparql.g:365:35: ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12138  
             loop89:
 12139  
             do {
 12140  260
                 int alt89=2;
 12141  260
                 switch ( input.LA(1) ) {
 12142  
                 case SEMICOLON:
 12143  
                     {
 12144  30
                     alt89=1;
 12145  
                     }
 12146  
                     break;
 12147  
 
 12148  
                 }
 12149  
 
 12150  260
                 switch (alt89) {
 12151  
                     case 1 :
 12152  
                         // com\\googlecode\\sparkleg\\Sparql.g:365:36: SEMICOLON ( propertyListNotEmptyDetails )?
 12153  
                         {
 12154  30
                         SEMICOLON268=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_propertyListNotEmpty3020);  
 12155  30
                         stream_SEMICOLON.add(SEMICOLON268);
 12156  
 
 12157  
 
 12158  
                         // com\\googlecode\\sparkleg\\Sparql.g:365:46: ( propertyListNotEmptyDetails )?
 12159  30
                         int alt88=2;
 12160  30
                         switch ( input.LA(1) ) {
 12161  
                             case A:
 12162  
                             case INVERSE:
 12163  
                             case IRI_REF:
 12164  
                             case NEGATION:
 12165  
                             case OPEN_BRACE:
 12166  
                             case PNAME_LN:
 12167  
                             case PNAME_NS:
 12168  
                             case VAR1:
 12169  
                             case VAR2:
 12170  
                                 {
 12171  28
                                 alt88=1;
 12172  
                                 }
 12173  
                                 break;
 12174  
                         }
 12175  
 
 12176  30
                         switch (alt88) {
 12177  
                             case 1 :
 12178  
                                 // com\\googlecode\\sparkleg\\Sparql.g:365:46: propertyListNotEmptyDetails
 12179  
                                 {
 12180  28
                                 pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3022);
 12181  28
                                 propertyListNotEmptyDetails269=propertyListNotEmptyDetails();
 12182  
 
 12183  28
                                 state._fsp--;
 12184  
 
 12185  28
                                 stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails269.getTree());
 12186  
 
 12187  
                                 }
 12188  
                                 break;
 12189  
 
 12190  
                         }
 12191  
 
 12192  
 
 12193  
                         }
 12194  30
                         break;
 12195  
 
 12196  
                     default :
 12197  230
                         break loop89;
 12198  
                 }
 12199  30
             } while (true);
 12200  
 
 12201  
 
 12202  
             // AST REWRITE
 12203  
             // elements: propertyListNotEmptyDetails
 12204  
             // token labels: 
 12205  
             // rule labels: retval
 12206  
             // token list labels: 
 12207  
             // rule list labels: 
 12208  
             // wildcard labels: 
 12209  230
             retval.tree = root_0;
 12210  230
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12211  
 
 12212  230
             root_0 = (Object)adaptor.nil();
 12213  
             // 365:77: -> ( propertyListNotEmptyDetails )+
 12214  
             {
 12215  230
                 if ( !(stream_propertyListNotEmptyDetails.hasNext()) ) {
 12216  0
                     throw new RewriteEarlyExitException();
 12217  
                 }
 12218  488
                 while ( stream_propertyListNotEmptyDetails.hasNext() ) {
 12219  258
                     adaptor.addChild(root_0, stream_propertyListNotEmptyDetails.nextTree());
 12220  
 
 12221  
                 }
 12222  230
                 stream_propertyListNotEmptyDetails.reset();
 12223  
 
 12224  
             }
 12225  
 
 12226  
 
 12227  230
             retval.tree = root_0;
 12228  
 
 12229  
             }
 12230  
 
 12231  230
             retval.stop = input.LT(-1);
 12232  
 
 12233  
 
 12234  230
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12235  230
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12236  
 
 12237  
         }
 12238  0
         catch (RecognitionException re) {
 12239  0
             reportError(re);
 12240  0
             recover(input,re);
 12241  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12242  
 
 12243  
         }
 12244  
 
 12245  0
         finally {
 12246  
                 // do for sure before leaving
 12247  230
         }
 12248  230
         return retval;
 12249  
     }
 12250  
     // $ANTLR end "propertyListNotEmpty"
 12251  
 
 12252  
 
 12253  3394
     public static class objectList_return extends ParserRuleReturnScope {
 12254  
         Object tree;
 12255  3394
         public Object getTree() { return tree; }
 12256  
     };
 12257  
 
 12258  
 
 12259  
     // $ANTLR start "objectList"
 12260  
     // com\\googlecode\\sparkleg\\Sparql.g:368:1: objectList : graphNode ( COMMA graphNode )* -> ( ^( OBJECT graphNode ) )+ ;
 12261  
     public final SparqlParser.objectList_return objectList() throws RecognitionException {
 12262  3394
         SparqlParser.objectList_return retval = new SparqlParser.objectList_return();
 12263  3394
         retval.start = input.LT(1);
 12264  
 
 12265  
 
 12266  3394
         Object root_0 = null;
 12267  
 
 12268  3394
         Token COMMA271=null;
 12269  3394
         SparqlParser.graphNode_return graphNode270 =null;
 12270  
 
 12271  3394
         SparqlParser.graphNode_return graphNode272 =null;
 12272  
 
 12273  
 
 12274  3394
         Object COMMA271_tree=null;
 12275  3394
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 12276  3394
         RewriteRuleSubtreeStream stream_graphNode=new RewriteRuleSubtreeStream(adaptor,"rule graphNode");
 12277  
         try {
 12278  
             // com\\googlecode\\sparkleg\\Sparql.g:369:5: ( graphNode ( COMMA graphNode )* -> ( ^( OBJECT graphNode ) )+ )
 12279  
             // com\\googlecode\\sparkleg\\Sparql.g:369:7: graphNode ( COMMA graphNode )*
 12280  
             {
 12281  3394
             pushFollow(FOLLOW_graphNode_in_objectList3048);
 12282  3394
             graphNode270=graphNode();
 12283  
 
 12284  3394
             state._fsp--;
 12285  
 
 12286  3394
             stream_graphNode.add(graphNode270.getTree());
 12287  
 
 12288  
             // com\\googlecode\\sparkleg\\Sparql.g:369:17: ( COMMA graphNode )*
 12289  
             loop90:
 12290  
             do {
 12291  3408
                 int alt90=2;
 12292  3408
                 switch ( input.LA(1) ) {
 12293  
                 case COMMA:
 12294  
                     {
 12295  14
                     alt90=1;
 12296  
                     }
 12297  
                     break;
 12298  
 
 12299  
                 }
 12300  
 
 12301  3408
                 switch (alt90) {
 12302  
                     case 1 :
 12303  
                         // com\\googlecode\\sparkleg\\Sparql.g:369:18: COMMA graphNode
 12304  
                         {
 12305  14
                         COMMA271=(Token)match(input,COMMA,FOLLOW_COMMA_in_objectList3051);  
 12306  14
                         stream_COMMA.add(COMMA271);
 12307  
 
 12308  
 
 12309  14
                         pushFollow(FOLLOW_graphNode_in_objectList3053);
 12310  14
                         graphNode272=graphNode();
 12311  
 
 12312  14
                         state._fsp--;
 12313  
 
 12314  14
                         stream_graphNode.add(graphNode272.getTree());
 12315  
 
 12316  
                         }
 12317  14
                         break;
 12318  
 
 12319  
                     default :
 12320  3394
                         break loop90;
 12321  
                 }
 12322  14
             } while (true);
 12323  
 
 12324  
 
 12325  
             // AST REWRITE
 12326  
             // elements: graphNode
 12327  
             // token labels: 
 12328  
             // rule labels: retval
 12329  
             // token list labels: 
 12330  
             // rule list labels: 
 12331  
             // wildcard labels: 
 12332  3394
             retval.tree = root_0;
 12333  3394
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12334  
 
 12335  3394
             root_0 = (Object)adaptor.nil();
 12336  
             // 369:36: -> ( ^( OBJECT graphNode ) )+
 12337  
             {
 12338  3394
                 if ( !(stream_graphNode.hasNext()) ) {
 12339  0
                     throw new RewriteEarlyExitException();
 12340  
                 }
 12341  6802
                 while ( stream_graphNode.hasNext() ) {
 12342  
                     // com\\googlecode\\sparkleg\\Sparql.g:369:39: ^( OBJECT graphNode )
 12343  
                     {
 12344  3408
                     Object root_1 = (Object)adaptor.nil();
 12345  3408
                     root_1 = (Object)adaptor.becomeRoot(
 12346  
                     (Object)adaptor.create(OBJECT, "OBJECT")
 12347  
                     , root_1);
 12348  
 
 12349  3408
                     adaptor.addChild(root_1, stream_graphNode.nextTree());
 12350  
 
 12351  3408
                     adaptor.addChild(root_0, root_1);
 12352  3408
                     }
 12353  
 
 12354  
                 }
 12355  3394
                 stream_graphNode.reset();
 12356  
 
 12357  
             }
 12358  
 
 12359  
 
 12360  3394
             retval.tree = root_0;
 12361  
 
 12362  
             }
 12363  
 
 12364  3394
             retval.stop = input.LT(-1);
 12365  
 
 12366  
 
 12367  3394
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12368  3394
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12369  
 
 12370  
         }
 12371  0
         catch (RecognitionException re) {
 12372  0
             reportError(re);
 12373  0
             recover(input,re);
 12374  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12375  
 
 12376  
         }
 12377  
 
 12378  0
         finally {
 12379  
                 // do for sure before leaving
 12380  3394
         }
 12381  3394
         return retval;
 12382  
     }
 12383  
     // $ANTLR end "objectList"
 12384  
 
 12385  
 
 12386  0
     public static class verb_return extends ParserRuleReturnScope {
 12387  
         Object tree;
 12388  0
         public Object getTree() { return tree; }
 12389  
     };
 12390  
 
 12391  
 
 12392  
     // $ANTLR start "verb"
 12393  
     // com\\googlecode\\sparkleg\\Sparql.g:372:1: verb : ( varOrIRIref | A );
 12394  
     public final SparqlParser.verb_return verb() throws RecognitionException {
 12395  0
         SparqlParser.verb_return retval = new SparqlParser.verb_return();
 12396  0
         retval.start = input.LT(1);
 12397  
 
 12398  
 
 12399  0
         Object root_0 = null;
 12400  
 
 12401  0
         Token A274=null;
 12402  0
         SparqlParser.varOrIRIref_return varOrIRIref273 =null;
 12403  
 
 12404  
 
 12405  0
         Object A274_tree=null;
 12406  
 
 12407  
         try {
 12408  
             // com\\googlecode\\sparkleg\\Sparql.g:373:5: ( varOrIRIref | A )
 12409  0
             int alt91=2;
 12410  0
             switch ( input.LA(1) ) {
 12411  
             case IRI_REF:
 12412  
             case PNAME_LN:
 12413  
             case PNAME_NS:
 12414  
             case VAR1:
 12415  
             case VAR2:
 12416  
                 {
 12417  0
                 alt91=1;
 12418  
                 }
 12419  0
                 break;
 12420  
             case A:
 12421  
                 {
 12422  0
                 alt91=2;
 12423  
                 }
 12424  0
                 break;
 12425  
             default:
 12426  0
                 NoViableAltException nvae =
 12427  
                     new NoViableAltException("", 91, 0, input);
 12428  
 
 12429  0
                 throw nvae;
 12430  
 
 12431  
             }
 12432  
 
 12433  0
             switch (alt91) {
 12434  
                 case 1 :
 12435  
                     // com\\googlecode\\sparkleg\\Sparql.g:373:7: varOrIRIref
 12436  
                     {
 12437  0
                     root_0 = (Object)adaptor.nil();
 12438  
 
 12439  
 
 12440  0
                     pushFollow(FOLLOW_varOrIRIref_in_verb3081);
 12441  0
                     varOrIRIref273=varOrIRIref();
 12442  
 
 12443  0
                     state._fsp--;
 12444  
 
 12445  0
                     adaptor.addChild(root_0, varOrIRIref273.getTree());
 12446  
 
 12447  
                     }
 12448  0
                     break;
 12449  
                 case 2 :
 12450  
                     // com\\googlecode\\sparkleg\\Sparql.g:374:7: A
 12451  
                     {
 12452  0
                     root_0 = (Object)adaptor.nil();
 12453  
 
 12454  
 
 12455  0
                     A274=(Token)match(input,A,FOLLOW_A_in_verb3089); 
 12456  0
                     A274_tree = 
 12457  
                     (Object)adaptor.create(A274)
 12458  
                     ;
 12459  0
                     adaptor.addChild(root_0, A274_tree);
 12460  
 
 12461  
 
 12462  
                     }
 12463  
                     break;
 12464  
 
 12465  
             }
 12466  0
             retval.stop = input.LT(-1);
 12467  
 
 12468  
 
 12469  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12470  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12471  
 
 12472  
         }
 12473  0
         catch (RecognitionException re) {
 12474  0
             reportError(re);
 12475  0
             recover(input,re);
 12476  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12477  
 
 12478  
         }
 12479  
 
 12480  0
         finally {
 12481  
                 // do for sure before leaving
 12482  0
         }
 12483  0
         return retval;
 12484  
     }
 12485  
     // $ANTLR end "verb"
 12486  
 
 12487  
 
 12488  2964
     public static class triplesSameSubjectPath_return extends ParserRuleReturnScope {
 12489  
         Object tree;
 12490  2964
         public Object getTree() { return tree; }
 12491  
     };
 12492  
 
 12493  
 
 12494  
     // $ANTLR start "triplesSameSubjectPath"
 12495  
     // com\\googlecode\\sparkleg\\Sparql.g:377:1: triplesSameSubjectPath : ( varOrTerm propertyListNotEmptyPath -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 12496  
     public final SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath() throws RecognitionException {
 12497  2964
         SparqlParser.triplesSameSubjectPath_return retval = new SparqlParser.triplesSameSubjectPath_return();
 12498  2964
         retval.start = input.LT(1);
 12499  
 
 12500  
 
 12501  2964
         Object root_0 = null;
 12502  
 
 12503  2964
         SparqlParser.varOrTerm_return varOrTerm275 =null;
 12504  
 
 12505  2964
         SparqlParser.propertyListNotEmptyPath_return propertyListNotEmptyPath276 =null;
 12506  
 
 12507  2964
         SparqlParser.triplesNode_return triplesNode277 =null;
 12508  
 
 12509  2964
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty278 =null;
 12510  
 
 12511  
 
 12512  2964
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 12513  2964
         RewriteRuleSubtreeStream stream_varOrTerm=new RewriteRuleSubtreeStream(adaptor,"rule varOrTerm");
 12514  2964
         RewriteRuleSubtreeStream stream_triplesNode=new RewriteRuleSubtreeStream(adaptor,"rule triplesNode");
 12515  2964
         RewriteRuleSubtreeStream stream_propertyListNotEmptyPath=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyPath");
 12516  
         try {
 12517  
             // com\\googlecode\\sparkleg\\Sparql.g:378:5: ( varOrTerm propertyListNotEmptyPath -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 12518  2964
             int alt93=2;
 12519  2964
             switch ( input.LA(1) ) {
 12520  
             case BLANK_NODE_LABEL:
 12521  
             case DECIMAL:
 12522  
             case DECIMAL_NEGATIVE:
 12523  
             case DECIMAL_POSITIVE:
 12524  
             case DOUBLE:
 12525  
             case DOUBLE_NEGATIVE:
 12526  
             case DOUBLE_POSITIVE:
 12527  
             case FALSE:
 12528  
             case INTEGER:
 12529  
             case INTEGER_NEGATIVE:
 12530  
             case INTEGER_POSITIVE:
 12531  
             case IRI_REF:
 12532  
             case PNAME_LN:
 12533  
             case PNAME_NS:
 12534  
             case STRING_LITERAL1:
 12535  
             case STRING_LITERAL2:
 12536  
             case STRING_LITERAL_LONG1:
 12537  
             case STRING_LITERAL_LONG2:
 12538  
             case TRUE:
 12539  
             case VAR1:
 12540  
             case VAR2:
 12541  
                 {
 12542  2872
                 alt93=1;
 12543  
                 }
 12544  2872
                 break;
 12545  
             case OPEN_SQUARE_BRACKET:
 12546  
                 {
 12547  66
                 switch ( input.LA(2) ) {
 12548  
                 case CLOSE_SQUARE_BRACKET:
 12549  
                     {
 12550  54
                     alt93=1;
 12551  
                     }
 12552  54
                     break;
 12553  
                 case A:
 12554  
                 case INVERSE:
 12555  
                 case IRI_REF:
 12556  
                 case NEGATION:
 12557  
                 case OPEN_BRACE:
 12558  
                 case PNAME_LN:
 12559  
                 case PNAME_NS:
 12560  
                 case VAR1:
 12561  
                 case VAR2:
 12562  
                     {
 12563  8
                     alt93=2;
 12564  
                     }
 12565  8
                     break;
 12566  
                 default:
 12567  4
                     NoViableAltException nvae =
 12568  
                         new NoViableAltException("", 93, 2, input);
 12569  
 
 12570  4
                     throw nvae;
 12571  
 
 12572  
                 }
 12573  
 
 12574  
                 }
 12575  62
                 break;
 12576  
             case OPEN_BRACE:
 12577  
                 {
 12578  26
                 switch ( input.LA(2) ) {
 12579  
                 case CLOSE_BRACE:
 12580  
                     {
 12581  10
                     alt93=1;
 12582  
                     }
 12583  10
                     break;
 12584  
                 case BLANK_NODE_LABEL:
 12585  
                 case DECIMAL:
 12586  
                 case DECIMAL_NEGATIVE:
 12587  
                 case DECIMAL_POSITIVE:
 12588  
                 case DOUBLE:
 12589  
                 case DOUBLE_NEGATIVE:
 12590  
                 case DOUBLE_POSITIVE:
 12591  
                 case FALSE:
 12592  
                 case INTEGER:
 12593  
                 case INTEGER_NEGATIVE:
 12594  
                 case INTEGER_POSITIVE:
 12595  
                 case IRI_REF:
 12596  
                 case OPEN_BRACE:
 12597  
                 case OPEN_SQUARE_BRACKET:
 12598  
                 case PNAME_LN:
 12599  
                 case PNAME_NS:
 12600  
                 case STRING_LITERAL1:
 12601  
                 case STRING_LITERAL2:
 12602  
                 case STRING_LITERAL_LONG1:
 12603  
                 case STRING_LITERAL_LONG2:
 12604  
                 case TRUE:
 12605  
                 case VAR1:
 12606  
                 case VAR2:
 12607  
                     {
 12608  16
                     alt93=2;
 12609  
                     }
 12610  16
                     break;
 12611  
                 default:
 12612  0
                     NoViableAltException nvae =
 12613  
                         new NoViableAltException("", 93, 3, input);
 12614  
 
 12615  0
                     throw nvae;
 12616  
 
 12617  
                 }
 12618  
 
 12619  
                 }
 12620  26
                 break;
 12621  
             default:
 12622  0
                 NoViableAltException nvae =
 12623  
                     new NoViableAltException("", 93, 0, input);
 12624  
 
 12625  0
                 throw nvae;
 12626  
 
 12627  
             }
 12628  
 
 12629  2960
             switch (alt93) {
 12630  
                 case 1 :
 12631  
                     // com\\googlecode\\sparkleg\\Sparql.g:378:7: varOrTerm propertyListNotEmptyPath
 12632  
                     {
 12633  2936
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubjectPath3106);
 12634  2936
                     varOrTerm275=varOrTerm();
 12635  
 
 12636  2936
                     state._fsp--;
 12637  
 
 12638  2936
                     stream_varOrTerm.add(varOrTerm275.getTree());
 12639  
 
 12640  2936
                     pushFollow(FOLLOW_propertyListNotEmptyPath_in_triplesSameSubjectPath3108);
 12641  2936
                     propertyListNotEmptyPath276=propertyListNotEmptyPath();
 12642  
 
 12643  2936
                     state._fsp--;
 12644  
 
 12645  2936
                     stream_propertyListNotEmptyPath.add(propertyListNotEmptyPath276.getTree());
 12646  
 
 12647  
                     // AST REWRITE
 12648  
                     // elements: varOrTerm, propertyListNotEmptyPath
 12649  
                     // token labels: 
 12650  
                     // rule labels: retval
 12651  
                     // token list labels: 
 12652  
                     // rule list labels: 
 12653  
                     // wildcard labels: 
 12654  2936
                     retval.tree = root_0;
 12655  2936
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12656  
 
 12657  2936
                     root_0 = (Object)adaptor.nil();
 12658  
                     // 378:42: -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath )
 12659  
                     {
 12660  
                         // com\\googlecode\\sparkleg\\Sparql.g:378:45: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath )
 12661  
                         {
 12662  2936
                         Object root_1 = (Object)adaptor.nil();
 12663  2936
                         root_1 = (Object)adaptor.becomeRoot(
 12664  
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12665  
                         , root_1);
 12666  
 
 12667  
                         // com\\googlecode\\sparkleg\\Sparql.g:378:68: ^( SUBJECT varOrTerm )
 12668  
                         {
 12669  2936
                         Object root_2 = (Object)adaptor.nil();
 12670  2936
                         root_2 = (Object)adaptor.becomeRoot(
 12671  
                         (Object)adaptor.create(SUBJECT, "SUBJECT")
 12672  
                         , root_2);
 12673  
 
 12674  2936
                         adaptor.addChild(root_2, stream_varOrTerm.nextTree());
 12675  
 
 12676  2936
                         adaptor.addChild(root_1, root_2);
 12677  
                         }
 12678  
 
 12679  2936
                         adaptor.addChild(root_1, stream_propertyListNotEmptyPath.nextTree());
 12680  
 
 12681  2936
                         adaptor.addChild(root_0, root_1);
 12682  
                         }
 12683  
 
 12684  
                     }
 12685  
 
 12686  
 
 12687  2936
                     retval.tree = root_0;
 12688  
 
 12689  
                     }
 12690  2936
                     break;
 12691  
                 case 2 :
 12692  
                     // com\\googlecode\\sparkleg\\Sparql.g:379:7: triplesNode ( propertyListNotEmpty )?
 12693  
                     {
 12694  24
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubjectPath3130);
 12695  24
                     triplesNode277=triplesNode();
 12696  
 
 12697  24
                     state._fsp--;
 12698  
 
 12699  24
                     stream_triplesNode.add(triplesNode277.getTree());
 12700  
 
 12701  
                     // com\\googlecode\\sparkleg\\Sparql.g:379:19: ( propertyListNotEmpty )?
 12702  24
                     int alt92=2;
 12703  24
                     switch ( input.LA(1) ) {
 12704  
                         case A:
 12705  
                         case INVERSE:
 12706  
                         case IRI_REF:
 12707  
                         case NEGATION:
 12708  
                         case OPEN_BRACE:
 12709  
                         case PNAME_LN:
 12710  
                         case PNAME_NS:
 12711  
                         case VAR1:
 12712  
                         case VAR2:
 12713  
                             {
 12714  8
                             alt92=1;
 12715  
                             }
 12716  
                             break;
 12717  
                     }
 12718  
 
 12719  24
                     switch (alt92) {
 12720  
                         case 1 :
 12721  
                             // com\\googlecode\\sparkleg\\Sparql.g:379:19: propertyListNotEmpty
 12722  
                             {
 12723  8
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath3132);
 12724  8
                             propertyListNotEmpty278=propertyListNotEmpty();
 12725  
 
 12726  8
                             state._fsp--;
 12727  
 
 12728  8
                             stream_propertyListNotEmpty.add(propertyListNotEmpty278.getTree());
 12729  
 
 12730  
                             }
 12731  
                             break;
 12732  
 
 12733  
                     }
 12734  
 
 12735  
 
 12736  
                     // AST REWRITE
 12737  
                     // elements: triplesNode, propertyListNotEmpty
 12738  
                     // token labels: 
 12739  
                     // rule labels: retval
 12740  
                     // token list labels: 
 12741  
                     // rule list labels: 
 12742  
                     // wildcard labels: 
 12743  24
                     retval.tree = root_0;
 12744  24
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12745  
 
 12746  24
                     root_0 = (Object)adaptor.nil();
 12747  
                     // 379:41: -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12748  
                     {
 12749  
                         // com\\googlecode\\sparkleg\\Sparql.g:379:44: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12750  
                         {
 12751  24
                         Object root_1 = (Object)adaptor.nil();
 12752  24
                         root_1 = (Object)adaptor.becomeRoot(
 12753  
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12754  
                         , root_1);
 12755  
 
 12756  24
                         adaptor.addChild(root_1, stream_triplesNode.nextTree());
 12757  
 
 12758  
                         // com\\googlecode\\sparkleg\\Sparql.g:379:80: ( propertyListNotEmpty )?
 12759  24
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12760  8
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12761  
 
 12762  
                         }
 12763  24
                         stream_propertyListNotEmpty.reset();
 12764  
 
 12765  24
                         adaptor.addChild(root_0, root_1);
 12766  
                         }
 12767  
 
 12768  
                     }
 12769  
 
 12770  
 
 12771  24
                     retval.tree = root_0;
 12772  
 
 12773  
                     }
 12774  
                     break;
 12775  
 
 12776  
             }
 12777  2960
             retval.stop = input.LT(-1);
 12778  
 
 12779  
 
 12780  2960
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12781  2960
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12782  
 
 12783  
         }
 12784  4
         catch (RecognitionException re) {
 12785  4
             reportError(re);
 12786  4
             recover(input,re);
 12787  4
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12788  
 
 12789  
         }
 12790  
 
 12791  0
         finally {
 12792  
                 // do for sure before leaving
 12793  2964
         }
 12794  2964
         return retval;
 12795  
     }
 12796  
     // $ANTLR end "triplesSameSubjectPath"
 12797  
 
 12798  
 
 12799  2936
     public static class propertyListNotEmptyPath_return extends ParserRuleReturnScope {
 12800  
         Object tree;
 12801  2936
         public Object getTree() { return tree; }
 12802  
     };
 12803  
 
 12804  
 
 12805  
     // $ANTLR start "propertyListNotEmptyPath"
 12806  
     // com\\googlecode\\sparkleg\\Sparql.g:382:1: propertyListNotEmptyPath : propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ ;
 12807  
     public final SparqlParser.propertyListNotEmptyPath_return propertyListNotEmptyPath() throws RecognitionException {
 12808  2936
         SparqlParser.propertyListNotEmptyPath_return retval = new SparqlParser.propertyListNotEmptyPath_return();
 12809  2936
         retval.start = input.LT(1);
 12810  
 
 12811  
 
 12812  2936
         Object root_0 = null;
 12813  
 
 12814  2936
         Token SEMICOLON280=null;
 12815  2936
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails279 =null;
 12816  
 
 12817  2936
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails281 =null;
 12818  
 
 12819  
 
 12820  2936
         Object SEMICOLON280_tree=null;
 12821  2936
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 12822  2936
         RewriteRuleSubtreeStream stream_propertyListNotEmptyDetails=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyDetails");
 12823  
         try {
 12824  
             // com\\googlecode\\sparkleg\\Sparql.g:383:5: ( propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ )
 12825  
             // com\\googlecode\\sparkleg\\Sparql.g:383:7: propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12826  
             {
 12827  2936
             pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3164);
 12828  2936
             propertyListNotEmptyDetails279=propertyListNotEmptyDetails();
 12829  
 
 12830  2936
             state._fsp--;
 12831  
 
 12832  2936
             stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails279.getTree());
 12833  
 
 12834  
             // com\\googlecode\\sparkleg\\Sparql.g:383:35: ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12835  
             loop95:
 12836  
             do {
 12837  3148
                 int alt95=2;
 12838  3148
                 switch ( input.LA(1) ) {
 12839  
                 case SEMICOLON:
 12840  
                     {
 12841  212
                     alt95=1;
 12842  
                     }
 12843  
                     break;
 12844  
 
 12845  
                 }
 12846  
 
 12847  3148
                 switch (alt95) {
 12848  
                     case 1 :
 12849  
                         // com\\googlecode\\sparkleg\\Sparql.g:383:36: SEMICOLON ( propertyListNotEmptyDetails )?
 12850  
                         {
 12851  212
                         SEMICOLON280=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_propertyListNotEmptyPath3167);  
 12852  212
                         stream_SEMICOLON.add(SEMICOLON280);
 12853  
 
 12854  
 
 12855  
                         // com\\googlecode\\sparkleg\\Sparql.g:383:46: ( propertyListNotEmptyDetails )?
 12856  212
                         int alt94=2;
 12857  212
                         switch ( input.LA(1) ) {
 12858  
                             case A:
 12859  
                             case INVERSE:
 12860  
                             case IRI_REF:
 12861  
                             case NEGATION:
 12862  
                             case OPEN_BRACE:
 12863  
                             case PNAME_LN:
 12864  
                             case PNAME_NS:
 12865  
                             case VAR1:
 12866  
                             case VAR2:
 12867  
                                 {
 12868  200
                                 alt94=1;
 12869  
                                 }
 12870  
                                 break;
 12871  
                         }
 12872  
 
 12873  212
                         switch (alt94) {
 12874  
                             case 1 :
 12875  
                                 // com\\googlecode\\sparkleg\\Sparql.g:383:46: propertyListNotEmptyDetails
 12876  
                                 {
 12877  200
                                 pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3169);
 12878  200
                                 propertyListNotEmptyDetails281=propertyListNotEmptyDetails();
 12879  
 
 12880  200
                                 state._fsp--;
 12881  
 
 12882  200
                                 stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails281.getTree());
 12883  
 
 12884  
                                 }
 12885  
                                 break;
 12886  
 
 12887  
                         }
 12888  
 
 12889  
 
 12890  
                         }
 12891  212
                         break;
 12892  
 
 12893  
                     default :
 12894  2936
                         break loop95;
 12895  
                 }
 12896  212
             } while (true);
 12897  
 
 12898  
 
 12899  
             // AST REWRITE
 12900  
             // elements: propertyListNotEmptyDetails
 12901  
             // token labels: 
 12902  
             // rule labels: retval
 12903  
             // token list labels: 
 12904  
             // rule list labels: 
 12905  
             // wildcard labels: 
 12906  2936
             retval.tree = root_0;
 12907  2936
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12908  
 
 12909  2936
             root_0 = (Object)adaptor.nil();
 12910  
             // 383:77: -> ( propertyListNotEmptyDetails )+
 12911  
             {
 12912  2936
                 if ( !(stream_propertyListNotEmptyDetails.hasNext()) ) {
 12913  0
                     throw new RewriteEarlyExitException();
 12914  
                 }
 12915  6072
                 while ( stream_propertyListNotEmptyDetails.hasNext() ) {
 12916  3136
                     adaptor.addChild(root_0, stream_propertyListNotEmptyDetails.nextTree());
 12917  
 
 12918  
                 }
 12919  2936
                 stream_propertyListNotEmptyDetails.reset();
 12920  
 
 12921  
             }
 12922  
 
 12923  
 
 12924  2936
             retval.tree = root_0;
 12925  
 
 12926  
             }
 12927  
 
 12928  2936
             retval.stop = input.LT(-1);
 12929  
 
 12930  
 
 12931  2936
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12932  2936
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12933  
 
 12934  
         }
 12935  0
         catch (RecognitionException re) {
 12936  0
             reportError(re);
 12937  0
             recover(input,re);
 12938  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12939  
 
 12940  
         }
 12941  
 
 12942  0
         finally {
 12943  
                 // do for sure before leaving
 12944  2936
         }
 12945  2936
         return retval;
 12946  
     }
 12947  
     // $ANTLR end "propertyListNotEmptyPath"
 12948  
 
 12949  
 
 12950  3394
     public static class propertyListNotEmptyDetails_return extends ParserRuleReturnScope {
 12951  
         Object tree;
 12952  3394
         public Object getTree() { return tree; }
 12953  
     };
 12954  
 
 12955  
 
 12956  
     // $ANTLR start "propertyListNotEmptyDetails"
 12957  
     // com\\googlecode\\sparkleg\\Sparql.g:386:1: propertyListNotEmptyDetails : verbSimpleOrPath objectList -> ^( PREDICATE verbSimpleOrPath objectList ) ;
 12958  
     public final SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails() throws RecognitionException {
 12959  3394
         SparqlParser.propertyListNotEmptyDetails_return retval = new SparqlParser.propertyListNotEmptyDetails_return();
 12960  3394
         retval.start = input.LT(1);
 12961  
 
 12962  
 
 12963  3394
         Object root_0 = null;
 12964  
 
 12965  3394
         SparqlParser.verbSimpleOrPath_return verbSimpleOrPath282 =null;
 12966  
 
 12967  3394
         SparqlParser.objectList_return objectList283 =null;
 12968  
 
 12969  
 
 12970  3394
         RewriteRuleSubtreeStream stream_verbSimpleOrPath=new RewriteRuleSubtreeStream(adaptor,"rule verbSimpleOrPath");
 12971  3394
         RewriteRuleSubtreeStream stream_objectList=new RewriteRuleSubtreeStream(adaptor,"rule objectList");
 12972  
         try {
 12973  
             // com\\googlecode\\sparkleg\\Sparql.g:387:5: ( verbSimpleOrPath objectList -> ^( PREDICATE verbSimpleOrPath objectList ) )
 12974  
             // com\\googlecode\\sparkleg\\Sparql.g:387:7: verbSimpleOrPath objectList
 12975  
             {
 12976  3394
             pushFollow(FOLLOW_verbSimpleOrPath_in_propertyListNotEmptyDetails3196);
 12977  3394
             verbSimpleOrPath282=verbSimpleOrPath();
 12978  
 
 12979  3394
             state._fsp--;
 12980  
 
 12981  3394
             stream_verbSimpleOrPath.add(verbSimpleOrPath282.getTree());
 12982  
 
 12983  3394
             pushFollow(FOLLOW_objectList_in_propertyListNotEmptyDetails3198);
 12984  3394
             objectList283=objectList();
 12985  
 
 12986  3394
             state._fsp--;
 12987  
 
 12988  3394
             stream_objectList.add(objectList283.getTree());
 12989  
 
 12990  
             // AST REWRITE
 12991  
             // elements: verbSimpleOrPath, objectList
 12992  
             // token labels: 
 12993  
             // rule labels: retval
 12994  
             // token list labels: 
 12995  
             // rule list labels: 
 12996  
             // wildcard labels: 
 12997  3394
             retval.tree = root_0;
 12998  3394
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12999  
 
 13000  3394
             root_0 = (Object)adaptor.nil();
 13001  
             // 387:35: -> ^( PREDICATE verbSimpleOrPath objectList )
 13002  
             {
 13003  
                 // com\\googlecode\\sparkleg\\Sparql.g:387:38: ^( PREDICATE verbSimpleOrPath objectList )
 13004  
                 {
 13005  3394
                 Object root_1 = (Object)adaptor.nil();
 13006  3394
                 root_1 = (Object)adaptor.becomeRoot(
 13007  
                 (Object)adaptor.create(PREDICATE, "PREDICATE")
 13008  
                 , root_1);
 13009  
 
 13010  3394
                 adaptor.addChild(root_1, stream_verbSimpleOrPath.nextTree());
 13011  
 
 13012  3394
                 adaptor.addChild(root_1, stream_objectList.nextTree());
 13013  
 
 13014  3394
                 adaptor.addChild(root_0, root_1);
 13015  
                 }
 13016  
 
 13017  
             }
 13018  
 
 13019  
 
 13020  3394
             retval.tree = root_0;
 13021  
 
 13022  
             }
 13023  
 
 13024  3394
             retval.stop = input.LT(-1);
 13025  
 
 13026  
 
 13027  3394
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13028  3394
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13029  
 
 13030  
         }
 13031  0
         catch (RecognitionException re) {
 13032  0
             reportError(re);
 13033  0
             recover(input,re);
 13034  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13035  
 
 13036  
         }
 13037  
 
 13038  0
         finally {
 13039  
                 // do for sure before leaving
 13040  3394
         }
 13041  3394
         return retval;
 13042  
     }
 13043  
     // $ANTLR end "propertyListNotEmptyDetails"
 13044  
 
 13045  
 
 13046  3394
     public static class verbSimpleOrPath_return extends ParserRuleReturnScope {
 13047  
         Object tree;
 13048  3394
         public Object getTree() { return tree; }
 13049  
     };
 13050  
 
 13051  
 
 13052  
     // $ANTLR start "verbSimpleOrPath"
 13053  
     // com\\googlecode\\sparkleg\\Sparql.g:390:1: verbSimpleOrPath : ( verbPath | verbSimple );
 13054  
     public final SparqlParser.verbSimpleOrPath_return verbSimpleOrPath() throws RecognitionException {
 13055  3394
         SparqlParser.verbSimpleOrPath_return retval = new SparqlParser.verbSimpleOrPath_return();
 13056  3394
         retval.start = input.LT(1);
 13057  
 
 13058  
 
 13059  3394
         Object root_0 = null;
 13060  
 
 13061  3394
         SparqlParser.verbPath_return verbPath284 =null;
 13062  
 
 13063  3394
         SparqlParser.verbSimple_return verbSimple285 =null;
 13064  
 
 13065  
 
 13066  
 
 13067  
         try {
 13068  
             // com\\googlecode\\sparkleg\\Sparql.g:391:5: ( verbPath | verbSimple )
 13069  3394
             int alt96=2;
 13070  3394
             switch ( input.LA(1) ) {
 13071  
             case A:
 13072  
             case INVERSE:
 13073  
             case IRI_REF:
 13074  
             case NEGATION:
 13075  
             case OPEN_BRACE:
 13076  
             case PNAME_LN:
 13077  
             case PNAME_NS:
 13078  
                 {
 13079  2672
                 alt96=1;
 13080  
                 }
 13081  2672
                 break;
 13082  
             case VAR1:
 13083  
             case VAR2:
 13084  
                 {
 13085  702
                 alt96=2;
 13086  
                 }
 13087  702
                 break;
 13088  
             default:
 13089  20
                 NoViableAltException nvae =
 13090  
                     new NoViableAltException("", 96, 0, input);
 13091  
 
 13092  20
                 throw nvae;
 13093  
 
 13094  
             }
 13095  
 
 13096  3374
             switch (alt96) {
 13097  
                 case 1 :
 13098  
                     // com\\googlecode\\sparkleg\\Sparql.g:391:7: verbPath
 13099  
                     {
 13100  2672
                     root_0 = (Object)adaptor.nil();
 13101  
 
 13102  
 
 13103  2672
                     pushFollow(FOLLOW_verbPath_in_verbSimpleOrPath3228);
 13104  2672
                     verbPath284=verbPath();
 13105  
 
 13106  2672
                     state._fsp--;
 13107  
 
 13108  2672
                     adaptor.addChild(root_0, verbPath284.getTree());
 13109  
 
 13110  
                     }
 13111  2672
                     break;
 13112  
                 case 2 :
 13113  
                     // com\\googlecode\\sparkleg\\Sparql.g:392:7: verbSimple
 13114  
                     {
 13115  702
                     root_0 = (Object)adaptor.nil();
 13116  
 
 13117  
 
 13118  702
                     pushFollow(FOLLOW_verbSimple_in_verbSimpleOrPath3236);
 13119  702
                     verbSimple285=verbSimple();
 13120  
 
 13121  702
                     state._fsp--;
 13122  
 
 13123  702
                     adaptor.addChild(root_0, verbSimple285.getTree());
 13124  
 
 13125  
                     }
 13126  
                     break;
 13127  
 
 13128  
             }
 13129  3374
             retval.stop = input.LT(-1);
 13130  
 
 13131  
 
 13132  3374
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13133  3374
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13134  
 
 13135  
         }
 13136  20
         catch (RecognitionException re) {
 13137  20
             reportError(re);
 13138  20
             recover(input,re);
 13139  20
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13140  
 
 13141  
         }
 13142  
 
 13143  0
         finally {
 13144  
                 // do for sure before leaving
 13145  3394
         }
 13146  3394
         return retval;
 13147  
     }
 13148  
     // $ANTLR end "verbSimpleOrPath"
 13149  
 
 13150  
 
 13151  2672
     public static class verbPath_return extends ParserRuleReturnScope {
 13152  
         Object tree;
 13153  2672
         public Object getTree() { return tree; }
 13154  
     };
 13155  
 
 13156  
 
 13157  
     // $ANTLR start "verbPath"
 13158  
     // com\\googlecode\\sparkleg\\Sparql.g:395:1: verbPath : path ;
 13159  
     public final SparqlParser.verbPath_return verbPath() throws RecognitionException {
 13160  2672
         SparqlParser.verbPath_return retval = new SparqlParser.verbPath_return();
 13161  2672
         retval.start = input.LT(1);
 13162  
 
 13163  
 
 13164  2672
         Object root_0 = null;
 13165  
 
 13166  2672
         SparqlParser.path_return path286 =null;
 13167  
 
 13168  
 
 13169  
 
 13170  
         try {
 13171  
             // com\\googlecode\\sparkleg\\Sparql.g:396:5: ( path )
 13172  
             // com\\googlecode\\sparkleg\\Sparql.g:396:7: path
 13173  
             {
 13174  2672
             root_0 = (Object)adaptor.nil();
 13175  
 
 13176  
 
 13177  2672
             pushFollow(FOLLOW_path_in_verbPath3255);
 13178  2672
             path286=path();
 13179  
 
 13180  2672
             state._fsp--;
 13181  
 
 13182  2672
             adaptor.addChild(root_0, path286.getTree());
 13183  
 
 13184  
             }
 13185  
 
 13186  2672
             retval.stop = input.LT(-1);
 13187  
 
 13188  
 
 13189  2672
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13190  2672
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13191  
 
 13192  
         }
 13193  0
         catch (RecognitionException re) {
 13194  0
             reportError(re);
 13195  0
             recover(input,re);
 13196  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13197  
 
 13198  
         }
 13199  
 
 13200  0
         finally {
 13201  
                 // do for sure before leaving
 13202  2672
         }
 13203  2672
         return retval;
 13204  
     }
 13205  
     // $ANTLR end "verbPath"
 13206  
 
 13207  
 
 13208  702
     public static class verbSimple_return extends ParserRuleReturnScope {
 13209  
         Object tree;
 13210  702
         public Object getTree() { return tree; }
 13211  
     };
 13212  
 
 13213  
 
 13214  
     // $ANTLR start "verbSimple"
 13215  
     // com\\googlecode\\sparkleg\\Sparql.g:399:1: verbSimple : var ;
 13216  
     public final SparqlParser.verbSimple_return verbSimple() throws RecognitionException {
 13217  702
         SparqlParser.verbSimple_return retval = new SparqlParser.verbSimple_return();
 13218  702
         retval.start = input.LT(1);
 13219  
 
 13220  
 
 13221  702
         Object root_0 = null;
 13222  
 
 13223  702
         SparqlParser.var_return var287 =null;
 13224  
 
 13225  
 
 13226  
 
 13227  
         try {
 13228  
             // com\\googlecode\\sparkleg\\Sparql.g:400:5: ( var )
 13229  
             // com\\googlecode\\sparkleg\\Sparql.g:400:7: var
 13230  
             {
 13231  702
             root_0 = (Object)adaptor.nil();
 13232  
 
 13233  
 
 13234  702
             pushFollow(FOLLOW_var_in_verbSimple3276);
 13235  702
             var287=var();
 13236  
 
 13237  702
             state._fsp--;
 13238  
 
 13239  702
             adaptor.addChild(root_0, var287.getTree());
 13240  
 
 13241  
             }
 13242  
 
 13243  702
             retval.stop = input.LT(-1);
 13244  
 
 13245  
 
 13246  702
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13247  702
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13248  
 
 13249  
         }
 13250  0
         catch (RecognitionException re) {
 13251  0
             reportError(re);
 13252  0
             recover(input,re);
 13253  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13254  
 
 13255  
         }
 13256  
 
 13257  0
         finally {
 13258  
                 // do for sure before leaving
 13259  702
         }
 13260  702
         return retval;
 13261  
     }
 13262  
     // $ANTLR end "verbSimple"
 13263  
 
 13264  
 
 13265  2692
     public static class path_return extends ParserRuleReturnScope {
 13266  
         Object tree;
 13267  2692
         public Object getTree() { return tree; }
 13268  
     };
 13269  
 
 13270  
 
 13271  
     // $ANTLR start "path"
 13272  
     // com\\googlecode\\sparkleg\\Sparql.g:403:1: path : pathSequence ( PIPE pathSequence )* -> ^( PATH ( pathSequence )+ ) ;
 13273  
     public final SparqlParser.path_return path() throws RecognitionException {
 13274  2692
         SparqlParser.path_return retval = new SparqlParser.path_return();
 13275  2692
         retval.start = input.LT(1);
 13276  
 
 13277  
 
 13278  2692
         Object root_0 = null;
 13279  
 
 13280  2692
         Token PIPE289=null;
 13281  2692
         SparqlParser.pathSequence_return pathSequence288 =null;
 13282  
 
 13283  2692
         SparqlParser.pathSequence_return pathSequence290 =null;
 13284  
 
 13285  
 
 13286  2692
         Object PIPE289_tree=null;
 13287  2692
         RewriteRuleTokenStream stream_PIPE=new RewriteRuleTokenStream(adaptor,"token PIPE");
 13288  2692
         RewriteRuleSubtreeStream stream_pathSequence=new RewriteRuleSubtreeStream(adaptor,"rule pathSequence");
 13289  
         try {
 13290  
             // com\\googlecode\\sparkleg\\Sparql.g:404:5: ( pathSequence ( PIPE pathSequence )* -> ^( PATH ( pathSequence )+ ) )
 13291  
             // com\\googlecode\\sparkleg\\Sparql.g:404:7: pathSequence ( PIPE pathSequence )*
 13292  
             {
 13293  2692
             pushFollow(FOLLOW_pathSequence_in_path3298);
 13294  2692
             pathSequence288=pathSequence();
 13295  
 
 13296  2692
             state._fsp--;
 13297  
 
 13298  2692
             stream_pathSequence.add(pathSequence288.getTree());
 13299  
 
 13300  
             // com\\googlecode\\sparkleg\\Sparql.g:404:20: ( PIPE pathSequence )*
 13301  
             loop97:
 13302  
             do {
 13303  2712
                 int alt97=2;
 13304  2712
                 switch ( input.LA(1) ) {
 13305  
                 case PIPE:
 13306  
                     {
 13307  20
                     alt97=1;
 13308  
                     }
 13309  
                     break;
 13310  
 
 13311  
                 }
 13312  
 
 13313  2712
                 switch (alt97) {
 13314  
                     case 1 :
 13315  
                         // com\\googlecode\\sparkleg\\Sparql.g:404:21: PIPE pathSequence
 13316  
                         {
 13317  20
                         PIPE289=(Token)match(input,PIPE,FOLLOW_PIPE_in_path3301);  
 13318  20
                         stream_PIPE.add(PIPE289);
 13319  
 
 13320  
 
 13321  20
                         pushFollow(FOLLOW_pathSequence_in_path3303);
 13322  20
                         pathSequence290=pathSequence();
 13323  
 
 13324  20
                         state._fsp--;
 13325  
 
 13326  20
                         stream_pathSequence.add(pathSequence290.getTree());
 13327  
 
 13328  
                         }
 13329  20
                         break;
 13330  
 
 13331  
                     default :
 13332  2692
                         break loop97;
 13333  
                 }
 13334  20
             } while (true);
 13335  
 
 13336  
 
 13337  
             // AST REWRITE
 13338  
             // elements: pathSequence
 13339  
             // token labels: 
 13340  
             // rule labels: retval
 13341  
             // token list labels: 
 13342  
             // rule list labels: 
 13343  
             // wildcard labels: 
 13344  2692
             retval.tree = root_0;
 13345  2692
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13346  
 
 13347  2692
             root_0 = (Object)adaptor.nil();
 13348  
             // 404:41: -> ^( PATH ( pathSequence )+ )
 13349  
             {
 13350  
                 // com\\googlecode\\sparkleg\\Sparql.g:404:44: ^( PATH ( pathSequence )+ )
 13351  
                 {
 13352  2692
                 Object root_1 = (Object)adaptor.nil();
 13353  2692
                 root_1 = (Object)adaptor.becomeRoot(
 13354  
                 (Object)adaptor.create(PATH, "PATH")
 13355  
                 , root_1);
 13356  
 
 13357  2692
                 if ( !(stream_pathSequence.hasNext()) ) {
 13358  0
                     throw new RewriteEarlyExitException();
 13359  
                 }
 13360  5404
                 while ( stream_pathSequence.hasNext() ) {
 13361  2712
                     adaptor.addChild(root_1, stream_pathSequence.nextTree());
 13362  
 
 13363  
                 }
 13364  2692
                 stream_pathSequence.reset();
 13365  
 
 13366  2692
                 adaptor.addChild(root_0, root_1);
 13367  
                 }
 13368  
 
 13369  
             }
 13370  
 
 13371  
 
 13372  2692
             retval.tree = root_0;
 13373  
 
 13374  
             }
 13375  
 
 13376  2692
             retval.stop = input.LT(-1);
 13377  
 
 13378  
 
 13379  2692
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13380  2692
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13381  
 
 13382  
         }
 13383  0
         catch (RecognitionException re) {
 13384  0
             reportError(re);
 13385  0
             recover(input,re);
 13386  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13387  
 
 13388  
         }
 13389  
 
 13390  0
         finally {
 13391  
                 // do for sure before leaving
 13392  2692
         }
 13393  2692
         return retval;
 13394  
     }
 13395  
     // $ANTLR end "path"
 13396  
 
 13397  
 
 13398  2712
     public static class pathSequence_return extends ParserRuleReturnScope {
 13399  
         Object tree;
 13400  2712
         public Object getTree() { return tree; }
 13401  
     };
 13402  
 
 13403  
 
 13404  
     // $ANTLR start "pathSequence"
 13405  
     // com\\googlecode\\sparkleg\\Sparql.g:407:1: pathSequence : pathEltOrInverse ( DIVIDE pathEltOrInverse )* -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) ;
 13406  
     public final SparqlParser.pathSequence_return pathSequence() throws RecognitionException {
 13407  2712
         SparqlParser.pathSequence_return retval = new SparqlParser.pathSequence_return();
 13408  2712
         retval.start = input.LT(1);
 13409  
 
 13410  
 
 13411  2712
         Object root_0 = null;
 13412  
 
 13413  2712
         Token DIVIDE292=null;
 13414  2712
         SparqlParser.pathEltOrInverse_return pathEltOrInverse291 =null;
 13415  
 
 13416  2712
         SparqlParser.pathEltOrInverse_return pathEltOrInverse293 =null;
 13417  
 
 13418  
 
 13419  2712
         Object DIVIDE292_tree=null;
 13420  2712
         RewriteRuleTokenStream stream_DIVIDE=new RewriteRuleTokenStream(adaptor,"token DIVIDE");
 13421  2712
         RewriteRuleSubtreeStream stream_pathEltOrInverse=new RewriteRuleSubtreeStream(adaptor,"rule pathEltOrInverse");
 13422  
         try {
 13423  
             // com\\googlecode\\sparkleg\\Sparql.g:408:5: ( pathEltOrInverse ( DIVIDE pathEltOrInverse )* -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) )
 13424  
             // com\\googlecode\\sparkleg\\Sparql.g:408:7: pathEltOrInverse ( DIVIDE pathEltOrInverse )*
 13425  
             {
 13426  2712
             pushFollow(FOLLOW_pathEltOrInverse_in_pathSequence3332);
 13427  2712
             pathEltOrInverse291=pathEltOrInverse();
 13428  
 
 13429  2712
             state._fsp--;
 13430  
 
 13431  2712
             stream_pathEltOrInverse.add(pathEltOrInverse291.getTree());
 13432  
 
 13433  
             // com\\googlecode\\sparkleg\\Sparql.g:408:24: ( DIVIDE pathEltOrInverse )*
 13434  
             loop98:
 13435  
             do {
 13436  2776
                 int alt98=2;
 13437  2776
                 switch ( input.LA(1) ) {
 13438  
                 case DIVIDE:
 13439  
                     {
 13440  64
                     alt98=1;
 13441  
                     }
 13442  
                     break;
 13443  
 
 13444  
                 }
 13445  
 
 13446  2776
                 switch (alt98) {
 13447  
                     case 1 :
 13448  
                         // com\\googlecode\\sparkleg\\Sparql.g:408:25: DIVIDE pathEltOrInverse
 13449  
                         {
 13450  64
                         DIVIDE292=(Token)match(input,DIVIDE,FOLLOW_DIVIDE_in_pathSequence3335);  
 13451  64
                         stream_DIVIDE.add(DIVIDE292);
 13452  
 
 13453  
 
 13454  64
                         pushFollow(FOLLOW_pathEltOrInverse_in_pathSequence3337);
 13455  64
                         pathEltOrInverse293=pathEltOrInverse();
 13456  
 
 13457  64
                         state._fsp--;
 13458  
 
 13459  64
                         stream_pathEltOrInverse.add(pathEltOrInverse293.getTree());
 13460  
 
 13461  
                         }
 13462  64
                         break;
 13463  
 
 13464  
                     default :
 13465  2712
                         break loop98;
 13466  
                 }
 13467  64
             } while (true);
 13468  
 
 13469  
 
 13470  
             // AST REWRITE
 13471  
             // elements: pathEltOrInverse
 13472  
             // token labels: 
 13473  
             // rule labels: retval
 13474  
             // token list labels: 
 13475  
             // rule list labels: 
 13476  
             // wildcard labels: 
 13477  2712
             retval.tree = root_0;
 13478  2712
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13479  
 
 13480  2712
             root_0 = (Object)adaptor.nil();
 13481  
             // 408:51: -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ )
 13482  
             {
 13483  
                 // com\\googlecode\\sparkleg\\Sparql.g:408:54: ^( PATH_SEQUENCE ( pathEltOrInverse )+ )
 13484  
                 {
 13485  2712
                 Object root_1 = (Object)adaptor.nil();
 13486  2712
                 root_1 = (Object)adaptor.becomeRoot(
 13487  
                 (Object)adaptor.create(PATH_SEQUENCE, "PATH_SEQUENCE")
 13488  
                 , root_1);
 13489  
 
 13490  2712
                 if ( !(stream_pathEltOrInverse.hasNext()) ) {
 13491  0
                     throw new RewriteEarlyExitException();
 13492  
                 }
 13493  5488
                 while ( stream_pathEltOrInverse.hasNext() ) {
 13494  2776
                     adaptor.addChild(root_1, stream_pathEltOrInverse.nextTree());
 13495  
 
 13496  
                 }
 13497  2712
                 stream_pathEltOrInverse.reset();
 13498  
 
 13499  2712
                 adaptor.addChild(root_0, root_1);
 13500  
                 }
 13501  
 
 13502  
             }
 13503  
 
 13504  
 
 13505  2712
             retval.tree = root_0;
 13506  
 
 13507  
             }
 13508  
 
 13509  2712
             retval.stop = input.LT(-1);
 13510  
 
 13511  
 
 13512  2712
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13513  2712
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13514  
 
 13515  
         }
 13516  0
         catch (RecognitionException re) {
 13517  0
             reportError(re);
 13518  0
             recover(input,re);
 13519  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13520  
 
 13521  
         }
 13522  
 
 13523  0
         finally {
 13524  
                 // do for sure before leaving
 13525  2712
         }
 13526  2712
         return retval;
 13527  
     }
 13528  
     // $ANTLR end "pathSequence"
 13529  
 
 13530  
 
 13531  2776
     public static class pathEltOrInverse_return extends ParserRuleReturnScope {
 13532  
         Object tree;
 13533  2776
         public Object getTree() { return tree; }
 13534  
     };
 13535  
 
 13536  
 
 13537  
     // $ANTLR start "pathEltOrInverse"
 13538  
     // com\\googlecode\\sparkleg\\Sparql.g:411:1: pathEltOrInverse : ( INVERSE )? pathElt ;
 13539  
     public final SparqlParser.pathEltOrInverse_return pathEltOrInverse() throws RecognitionException {
 13540  2776
         SparqlParser.pathEltOrInverse_return retval = new SparqlParser.pathEltOrInverse_return();
 13541  2776
         retval.start = input.LT(1);
 13542  
 
 13543  
 
 13544  2776
         Object root_0 = null;
 13545  
 
 13546  2776
         Token INVERSE294=null;
 13547  2776
         SparqlParser.pathElt_return pathElt295 =null;
 13548  
 
 13549  
 
 13550  2776
         Object INVERSE294_tree=null;
 13551  
 
 13552  
         try {
 13553  
             // com\\googlecode\\sparkleg\\Sparql.g:412:5: ( ( INVERSE )? pathElt )
 13554  
             // com\\googlecode\\sparkleg\\Sparql.g:412:7: ( INVERSE )? pathElt
 13555  
             {
 13556  2776
             root_0 = (Object)adaptor.nil();
 13557  
 
 13558  
 
 13559  
             // com\\googlecode\\sparkleg\\Sparql.g:412:7: ( INVERSE )?
 13560  2776
             int alt99=2;
 13561  2776
             switch ( input.LA(1) ) {
 13562  
                 case INVERSE:
 13563  
                     {
 13564  12
                     alt99=1;
 13565  
                     }
 13566  
                     break;
 13567  
             }
 13568  
 
 13569  2776
             switch (alt99) {
 13570  
                 case 1 :
 13571  
                     // com\\googlecode\\sparkleg\\Sparql.g:412:7: INVERSE
 13572  
                     {
 13573  12
                     INVERSE294=(Token)match(input,INVERSE,FOLLOW_INVERSE_in_pathEltOrInverse3365); 
 13574  12
                     INVERSE294_tree = 
 13575  
                     (Object)adaptor.create(INVERSE294)
 13576  
                     ;
 13577  12
                     adaptor.addChild(root_0, INVERSE294_tree);
 13578  
 
 13579  
 
 13580  
                     }
 13581  
                     break;
 13582  
 
 13583  
             }
 13584  
 
 13585  
 
 13586  2776
             pushFollow(FOLLOW_pathElt_in_pathEltOrInverse3368);
 13587  2776
             pathElt295=pathElt();
 13588  
 
 13589  2776
             state._fsp--;
 13590  
 
 13591  2776
             adaptor.addChild(root_0, pathElt295.getTree());
 13592  
 
 13593  
             }
 13594  
 
 13595  2776
             retval.stop = input.LT(-1);
 13596  
 
 13597  
 
 13598  2776
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13599  2776
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13600  
 
 13601  
         }
 13602  0
         catch (RecognitionException re) {
 13603  0
             reportError(re);
 13604  0
             recover(input,re);
 13605  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13606  
 
 13607  
         }
 13608  
 
 13609  0
         finally {
 13610  
                 // do for sure before leaving
 13611  2776
         }
 13612  2776
         return retval;
 13613  
     }
 13614  
     // $ANTLR end "pathEltOrInverse"
 13615  
 
 13616  
 
 13617  2776
     public static class pathElt_return extends ParserRuleReturnScope {
 13618  
         Object tree;
 13619  2776
         public Object getTree() { return tree; }
 13620  
     };
 13621  
 
 13622  
 
 13623  
     // $ANTLR start "pathElt"
 13624  
     // com\\googlecode\\sparkleg\\Sparql.g:415:1: pathElt : pathPrimary ( pathMod )? ;
 13625  
     public final SparqlParser.pathElt_return pathElt() throws RecognitionException {
 13626  2776
         SparqlParser.pathElt_return retval = new SparqlParser.pathElt_return();
 13627  2776
         retval.start = input.LT(1);
 13628  
 
 13629  
 
 13630  2776
         Object root_0 = null;
 13631  
 
 13632  2776
         SparqlParser.pathPrimary_return pathPrimary296 =null;
 13633  
 
 13634  2776
         SparqlParser.pathMod_return pathMod297 =null;
 13635  
 
 13636  
 
 13637  
 
 13638  
         try {
 13639  
             // com\\googlecode\\sparkleg\\Sparql.g:416:5: ( pathPrimary ( pathMod )? )
 13640  
             // com\\googlecode\\sparkleg\\Sparql.g:416:7: pathPrimary ( pathMod )?
 13641  
             {
 13642  2776
             root_0 = (Object)adaptor.nil();
 13643  
 
 13644  
 
 13645  2776
             pushFollow(FOLLOW_pathPrimary_in_pathElt3396);
 13646  2776
             pathPrimary296=pathPrimary();
 13647  
 
 13648  2776
             state._fsp--;
 13649  
 
 13650  2776
             adaptor.addChild(root_0, pathPrimary296.getTree());
 13651  
 
 13652  
             // com\\googlecode\\sparkleg\\Sparql.g:416:19: ( pathMod )?
 13653  2776
             int alt100=2;
 13654  2776
             switch ( input.LA(1) ) {
 13655  
                 case ASTERISK:
 13656  
                 case OPEN_CURLY_BRACE:
 13657  
                 case PLUS:
 13658  
                 case QUESTION_MARK:
 13659  
                     {
 13660  66
                     alt100=1;
 13661  
                     }
 13662  
                     break;
 13663  
             }
 13664  
 
 13665  2776
             switch (alt100) {
 13666  
                 case 1 :
 13667  
                     // com\\googlecode\\sparkleg\\Sparql.g:416:19: pathMod
 13668  
                     {
 13669  66
                     pushFollow(FOLLOW_pathMod_in_pathElt3398);
 13670  66
                     pathMod297=pathMod();
 13671  
 
 13672  66
                     state._fsp--;
 13673  
 
 13674  66
                     adaptor.addChild(root_0, pathMod297.getTree());
 13675  
 
 13676  
                     }
 13677  
                     break;
 13678  
 
 13679  
             }
 13680  
 
 13681  
 
 13682  
             }
 13683  
 
 13684  2776
             retval.stop = input.LT(-1);
 13685  
 
 13686  
 
 13687  2776
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13688  2776
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13689  
 
 13690  
         }
 13691  0
         catch (RecognitionException re) {
 13692  0
             reportError(re);
 13693  0
             recover(input,re);
 13694  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13695  
 
 13696  
         }
 13697  
 
 13698  0
         finally {
 13699  
                 // do for sure before leaving
 13700  2776
         }
 13701  2776
         return retval;
 13702  
     }
 13703  
     // $ANTLR end "pathElt"
 13704  
 
 13705  
 
 13706  66
     public static class pathMod_return extends ParserRuleReturnScope {
 13707  
         Object tree;
 13708  66
         public Object getTree() { return tree; }
 13709  
     };
 13710  
 
 13711  
 
 13712  
     // $ANTLR start "pathMod"
 13713  
     // com\\googlecode\\sparkleg\\Sparql.g:419:1: pathMod : ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) ) ;
 13714  
     public final SparqlParser.pathMod_return pathMod() throws RecognitionException {
 13715  66
         SparqlParser.pathMod_return retval = new SparqlParser.pathMod_return();
 13716  66
         retval.start = input.LT(1);
 13717  
 
 13718  
 
 13719  66
         Object root_0 = null;
 13720  
 
 13721  66
         Token ASTERISK298=null;
 13722  66
         Token QUESTION_MARK299=null;
 13723  66
         Token PLUS300=null;
 13724  66
         Token OPEN_CURLY_BRACE301=null;
 13725  66
         Token INTEGER302=null;
 13726  66
         Token COMMA303=null;
 13727  66
         Token CLOSE_CURLY_BRACE304=null;
 13728  66
         Token INTEGER305=null;
 13729  66
         Token CLOSE_CURLY_BRACE306=null;
 13730  66
         Token CLOSE_CURLY_BRACE307=null;
 13731  66
         Token COMMA308=null;
 13732  66
         Token INTEGER309=null;
 13733  66
         Token CLOSE_CURLY_BRACE310=null;
 13734  
 
 13735  66
         Object ASTERISK298_tree=null;
 13736  66
         Object QUESTION_MARK299_tree=null;
 13737  66
         Object PLUS300_tree=null;
 13738  66
         Object OPEN_CURLY_BRACE301_tree=null;
 13739  66
         Object INTEGER302_tree=null;
 13740  66
         Object COMMA303_tree=null;
 13741  66
         Object CLOSE_CURLY_BRACE304_tree=null;
 13742  66
         Object INTEGER305_tree=null;
 13743  66
         Object CLOSE_CURLY_BRACE306_tree=null;
 13744  66
         Object CLOSE_CURLY_BRACE307_tree=null;
 13745  66
         Object COMMA308_tree=null;
 13746  66
         Object INTEGER309_tree=null;
 13747  66
         Object CLOSE_CURLY_BRACE310_tree=null;
 13748  
 
 13749  
         try {
 13750  
             // com\\googlecode\\sparkleg\\Sparql.g:420:5: ( ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) ) )
 13751  
             // com\\googlecode\\sparkleg\\Sparql.g:420:7: ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) )
 13752  
             {
 13753  66
             root_0 = (Object)adaptor.nil();
 13754  
 
 13755  
 
 13756  
             // com\\googlecode\\sparkleg\\Sparql.g:420:7: ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) )
 13757  66
             int alt104=4;
 13758  66
             switch ( input.LA(1) ) {
 13759  
             case ASTERISK:
 13760  
                 {
 13761  18
                 alt104=1;
 13762  
                 }
 13763  18
                 break;
 13764  
             case QUESTION_MARK:
 13765  
                 {
 13766  2
                 alt104=2;
 13767  
                 }
 13768  2
                 break;
 13769  
             case PLUS:
 13770  
                 {
 13771  16
                 alt104=3;
 13772  
                 }
 13773  16
                 break;
 13774  
             case OPEN_CURLY_BRACE:
 13775  
                 {
 13776  30
                 alt104=4;
 13777  
                 }
 13778  30
                 break;
 13779  
             default:
 13780  0
                 NoViableAltException nvae =
 13781  
                     new NoViableAltException("", 104, 0, input);
 13782  
 
 13783  0
                 throw nvae;
 13784  
 
 13785  
             }
 13786  
 
 13787  66
             switch (alt104) {
 13788  
                 case 1 :
 13789  
                     // com\\googlecode\\sparkleg\\Sparql.g:420:8: ASTERISK
 13790  
                     {
 13791  18
                     ASTERISK298=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_pathMod3417); 
 13792  18
                     ASTERISK298_tree = 
 13793  
                     (Object)adaptor.create(ASTERISK298)
 13794  
                     ;
 13795  18
                     adaptor.addChild(root_0, ASTERISK298_tree);
 13796  
 
 13797  
 
 13798  
                     }
 13799  18
                     break;
 13800  
                 case 2 :
 13801  
                     // com\\googlecode\\sparkleg\\Sparql.g:420:19: QUESTION_MARK
 13802  
                     {
 13803  2
                     QUESTION_MARK299=(Token)match(input,QUESTION_MARK,FOLLOW_QUESTION_MARK_in_pathMod3421); 
 13804  2
                     QUESTION_MARK299_tree = 
 13805  
                     (Object)adaptor.create(QUESTION_MARK299)
 13806  
                     ;
 13807  2
                     adaptor.addChild(root_0, QUESTION_MARK299_tree);
 13808  
 
 13809  
 
 13810  
                     }
 13811  2
                     break;
 13812  
                 case 3 :
 13813  
                     // com\\googlecode\\sparkleg\\Sparql.g:420:35: PLUS
 13814  
                     {
 13815  16
                     PLUS300=(Token)match(input,PLUS,FOLLOW_PLUS_in_pathMod3425); 
 13816  16
                     PLUS300_tree = 
 13817  
                     (Object)adaptor.create(PLUS300)
 13818  
                     ;
 13819  16
                     adaptor.addChild(root_0, PLUS300_tree);
 13820  
 
 13821  
 
 13822  
                     }
 13823  16
                     break;
 13824  
                 case 4 :
 13825  
                     // com\\googlecode\\sparkleg\\Sparql.g:420:42: OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE )
 13826  
                     {
 13827  30
                     OPEN_CURLY_BRACE301=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_pathMod3429); 
 13828  30
                     OPEN_CURLY_BRACE301_tree = 
 13829  
                     (Object)adaptor.create(OPEN_CURLY_BRACE301)
 13830  
                     ;
 13831  30
                     adaptor.addChild(root_0, OPEN_CURLY_BRACE301_tree);
 13832  
 
 13833  
 
 13834  
                     // com\\googlecode\\sparkleg\\Sparql.g:420:59: ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE )
 13835  30
                     int alt103=2;
 13836  30
                     switch ( input.LA(1) ) {
 13837  
                     case INTEGER:
 13838  
                         {
 13839  28
                         alt103=1;
 13840  
                         }
 13841  28
                         break;
 13842  
                     case COMMA:
 13843  
                         {
 13844  2
                         alt103=2;
 13845  
                         }
 13846  2
                         break;
 13847  
                     default:
 13848  0
                         NoViableAltException nvae =
 13849  
                             new NoViableAltException("", 103, 0, input);
 13850  
 
 13851  0
                         throw nvae;
 13852  
 
 13853  
                     }
 13854  
 
 13855  30
                     switch (alt103) {
 13856  
                         case 1 :
 13857  
                             // com\\googlecode\\sparkleg\\Sparql.g:420:60: INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE )
 13858  
                             {
 13859  28
                             INTEGER302=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3432); 
 13860  28
                             INTEGER302_tree = 
 13861  
                             (Object)adaptor.create(INTEGER302)
 13862  
                             ;
 13863  28
                             adaptor.addChild(root_0, INTEGER302_tree);
 13864  
 
 13865  
 
 13866  
                             // com\\googlecode\\sparkleg\\Sparql.g:420:68: ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE )
 13867  28
                             int alt102=2;
 13868  28
                             switch ( input.LA(1) ) {
 13869  
                             case COMMA:
 13870  
                                 {
 13871  10
                                 alt102=1;
 13872  
                                 }
 13873  10
                                 break;
 13874  
                             case CLOSE_CURLY_BRACE:
 13875  
                                 {
 13876  18
                                 alt102=2;
 13877  
                                 }
 13878  18
                                 break;
 13879  
                             default:
 13880  0
                                 NoViableAltException nvae =
 13881  
                                     new NoViableAltException("", 102, 0, input);
 13882  
 
 13883  0
                                 throw nvae;
 13884  
 
 13885  
                             }
 13886  
 
 13887  28
                             switch (alt102) {
 13888  
                                 case 1 :
 13889  
                                     // com\\googlecode\\sparkleg\\Sparql.g:420:69: COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE )
 13890  
                                     {
 13891  10
                                     COMMA303=(Token)match(input,COMMA,FOLLOW_COMMA_in_pathMod3435); 
 13892  10
                                     COMMA303_tree = 
 13893  
                                     (Object)adaptor.create(COMMA303)
 13894  
                                     ;
 13895  10
                                     adaptor.addChild(root_0, COMMA303_tree);
 13896  
 
 13897  
 
 13898  
                                     // com\\googlecode\\sparkleg\\Sparql.g:420:75: ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE )
 13899  10
                                     int alt101=2;
 13900  10
                                     switch ( input.LA(1) ) {
 13901  
                                     case CLOSE_CURLY_BRACE:
 13902  
                                         {
 13903  6
                                         alt101=1;
 13904  
                                         }
 13905  6
                                         break;
 13906  
                                     case INTEGER:
 13907  
                                         {
 13908  4
                                         alt101=2;
 13909  
                                         }
 13910  4
                                         break;
 13911  
                                     default:
 13912  0
                                         NoViableAltException nvae =
 13913  
                                             new NoViableAltException("", 101, 0, input);
 13914  
 
 13915  0
                                         throw nvae;
 13916  
 
 13917  
                                     }
 13918  
 
 13919  10
                                     switch (alt101) {
 13920  
                                         case 1 :
 13921  
                                             // com\\googlecode\\sparkleg\\Sparql.g:420:76: CLOSE_CURLY_BRACE
 13922  
                                             {
 13923  6
                                             CLOSE_CURLY_BRACE304=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3438); 
 13924  6
                                             CLOSE_CURLY_BRACE304_tree = 
 13925  
                                             (Object)adaptor.create(CLOSE_CURLY_BRACE304)
 13926  
                                             ;
 13927  6
                                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE304_tree);
 13928  
 
 13929  
 
 13930  
                                             }
 13931  6
                                             break;
 13932  
                                         case 2 :
 13933  
                                             // com\\googlecode\\sparkleg\\Sparql.g:420:96: INTEGER CLOSE_CURLY_BRACE
 13934  
                                             {
 13935  4
                                             INTEGER305=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3442); 
 13936  4
                                             INTEGER305_tree = 
 13937  
                                             (Object)adaptor.create(INTEGER305)
 13938  
                                             ;
 13939  4
                                             adaptor.addChild(root_0, INTEGER305_tree);
 13940  
 
 13941  
 
 13942  4
                                             CLOSE_CURLY_BRACE306=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3444); 
 13943  4
                                             CLOSE_CURLY_BRACE306_tree = 
 13944  
                                             (Object)adaptor.create(CLOSE_CURLY_BRACE306)
 13945  
                                             ;
 13946  4
                                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE306_tree);
 13947  
 
 13948  
 
 13949  
                                             }
 13950  
                                             break;
 13951  
 
 13952  
                                     }
 13953  
 
 13954  
 
 13955  
                                     }
 13956  10
                                     break;
 13957  
                                 case 2 :
 13958  
                                     // com\\googlecode\\sparkleg\\Sparql.g:420:125: CLOSE_CURLY_BRACE
 13959  
                                     {
 13960  18
                                     CLOSE_CURLY_BRACE307=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3449); 
 13961  18
                                     CLOSE_CURLY_BRACE307_tree = 
 13962  
                                     (Object)adaptor.create(CLOSE_CURLY_BRACE307)
 13963  
                                     ;
 13964  18
                                     adaptor.addChild(root_0, CLOSE_CURLY_BRACE307_tree);
 13965  
 
 13966  
 
 13967  
                                     }
 13968  
                                     break;
 13969  
 
 13970  
                             }
 13971  
 
 13972  
 
 13973  
                             }
 13974  28
                             break;
 13975  
                         case 2 :
 13976  
                             // com\\googlecode\\sparkleg\\Sparql.g:420:146: COMMA INTEGER CLOSE_CURLY_BRACE
 13977  
                             {
 13978  2
                             COMMA308=(Token)match(input,COMMA,FOLLOW_COMMA_in_pathMod3454); 
 13979  2
                             COMMA308_tree = 
 13980  
                             (Object)adaptor.create(COMMA308)
 13981  
                             ;
 13982  2
                             adaptor.addChild(root_0, COMMA308_tree);
 13983  
 
 13984  
 
 13985  2
                             INTEGER309=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3456); 
 13986  2
                             INTEGER309_tree = 
 13987  
                             (Object)adaptor.create(INTEGER309)
 13988  
                             ;
 13989  2
                             adaptor.addChild(root_0, INTEGER309_tree);
 13990  
 
 13991  
 
 13992  2
                             CLOSE_CURLY_BRACE310=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3458); 
 13993  2
                             CLOSE_CURLY_BRACE310_tree = 
 13994  
                             (Object)adaptor.create(CLOSE_CURLY_BRACE310)
 13995  
                             ;
 13996  2
                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE310_tree);
 13997  
 
 13998  
 
 13999  
                             }
 14000  
                             break;
 14001  
 
 14002  
                     }
 14003  
 
 14004  
 
 14005  
                     }
 14006  
                     break;
 14007  
 
 14008  
             }
 14009  
 
 14010  
 
 14011  
             }
 14012  
 
 14013  66
             retval.stop = input.LT(-1);
 14014  
 
 14015  
 
 14016  66
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14017  66
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14018  
 
 14019  
         }
 14020  0
         catch (RecognitionException re) {
 14021  0
             reportError(re);
 14022  0
             recover(input,re);
 14023  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14024  
 
 14025  
         }
 14026  
 
 14027  0
         finally {
 14028  
                 // do for sure before leaving
 14029  66
         }
 14030  66
         return retval;
 14031  
     }
 14032  
     // $ANTLR end "pathMod"
 14033  
 
 14034  
 
 14035  2776
     public static class pathPrimary_return extends ParserRuleReturnScope {
 14036  
         Object tree;
 14037  2776
         public Object getTree() { return tree; }
 14038  
     };
 14039  
 
 14040  
 
 14041  
     // $ANTLR start "pathPrimary"
 14042  
     // com\\googlecode\\sparkleg\\Sparql.g:423:1: pathPrimary : ( iriRef -> ^( PATH_PRIMARY iriRef ) | A -> ^( PATH_PRIMARY A ) | NEGATION pathNegatedPropertySet -> ^( PATH_PRIMARY NEGATION pathNegatedPropertySet ) | OPEN_BRACE path CLOSE_BRACE -> ^( PATH_PRIMARY path ) );
 14043  
     public final SparqlParser.pathPrimary_return pathPrimary() throws RecognitionException {
 14044  2776
         SparqlParser.pathPrimary_return retval = new SparqlParser.pathPrimary_return();
 14045  2776
         retval.start = input.LT(1);
 14046  
 
 14047  
 
 14048  2776
         Object root_0 = null;
 14049  
 
 14050  2776
         Token A312=null;
 14051  2776
         Token NEGATION313=null;
 14052  2776
         Token OPEN_BRACE315=null;
 14053  2776
         Token CLOSE_BRACE317=null;
 14054  2776
         SparqlParser.iriRef_return iriRef311 =null;
 14055  
 
 14056  2776
         SparqlParser.pathNegatedPropertySet_return pathNegatedPropertySet314 =null;
 14057  
 
 14058  2776
         SparqlParser.path_return path316 =null;
 14059  
 
 14060  
 
 14061  2776
         Object A312_tree=null;
 14062  2776
         Object NEGATION313_tree=null;
 14063  2776
         Object OPEN_BRACE315_tree=null;
 14064  2776
         Object CLOSE_BRACE317_tree=null;
 14065  2776
         RewriteRuleTokenStream stream_A=new RewriteRuleTokenStream(adaptor,"token A");
 14066  2776
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 14067  2776
         RewriteRuleTokenStream stream_NEGATION=new RewriteRuleTokenStream(adaptor,"token NEGATION");
 14068  2776
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 14069  2776
         RewriteRuleSubtreeStream stream_path=new RewriteRuleSubtreeStream(adaptor,"rule path");
 14070  2776
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 14071  2776
         RewriteRuleSubtreeStream stream_pathNegatedPropertySet=new RewriteRuleSubtreeStream(adaptor,"rule pathNegatedPropertySet");
 14072  
         try {
 14073  
             // com\\googlecode\\sparkleg\\Sparql.g:424:5: ( iriRef -> ^( PATH_PRIMARY iriRef ) | A -> ^( PATH_PRIMARY A ) | NEGATION pathNegatedPropertySet -> ^( PATH_PRIMARY NEGATION pathNegatedPropertySet ) | OPEN_BRACE path CLOSE_BRACE -> ^( PATH_PRIMARY path ) )
 14074  2776
             int alt105=4;
 14075  2776
             switch ( input.LA(1) ) {
 14076  
             case IRI_REF:
 14077  
             case PNAME_LN:
 14078  
             case PNAME_NS:
 14079  
                 {
 14080  2686
                 alt105=1;
 14081  
                 }
 14082  2686
                 break;
 14083  
             case A:
 14084  
                 {
 14085  64
                 alt105=2;
 14086  
                 }
 14087  64
                 break;
 14088  
             case NEGATION:
 14089  
                 {
 14090  6
                 alt105=3;
 14091  
                 }
 14092  6
                 break;
 14093  
             case OPEN_BRACE:
 14094  
                 {
 14095  20
                 alt105=4;
 14096  
                 }
 14097  20
                 break;
 14098  
             default:
 14099  0
                 NoViableAltException nvae =
 14100  
                     new NoViableAltException("", 105, 0, input);
 14101  
 
 14102  0
                 throw nvae;
 14103  
 
 14104  
             }
 14105  
 
 14106  2776
             switch (alt105) {
 14107  
                 case 1 :
 14108  
                     // com\\googlecode\\sparkleg\\Sparql.g:424:7: iriRef
 14109  
                     {
 14110  2686
                     pushFollow(FOLLOW_iriRef_in_pathPrimary3477);
 14111  2686
                     iriRef311=iriRef();
 14112  
 
 14113  2686
                     state._fsp--;
 14114  
 
 14115  2686
                     stream_iriRef.add(iriRef311.getTree());
 14116  
 
 14117  
                     // AST REWRITE
 14118  
                     // elements: iriRef
 14119  
                     // token labels: 
 14120  
                     // rule labels: retval
 14121  
                     // token list labels: 
 14122  
                     // rule list labels: 
 14123  
                     // wildcard labels: 
 14124  2686
                     retval.tree = root_0;
 14125  2686
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14126  
 
 14127  2686
                     root_0 = (Object)adaptor.nil();
 14128  
                     // 424:14: -> ^( PATH_PRIMARY iriRef )
 14129  
                     {
 14130  
                         // com\\googlecode\\sparkleg\\Sparql.g:424:17: ^( PATH_PRIMARY iriRef )
 14131  
                         {
 14132  2686
                         Object root_1 = (Object)adaptor.nil();
 14133  2686
                         root_1 = (Object)adaptor.becomeRoot(
 14134  
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14135  
                         , root_1);
 14136  
 
 14137  2686
                         adaptor.addChild(root_1, stream_iriRef.nextTree());
 14138  
 
 14139  2686
                         adaptor.addChild(root_0, root_1);
 14140  
                         }
 14141  
 
 14142  
                     }
 14143  
 
 14144  
 
 14145  2686
                     retval.tree = root_0;
 14146  
 
 14147  
                     }
 14148  2686
                     break;
 14149  
                 case 2 :
 14150  
                     // com\\googlecode\\sparkleg\\Sparql.g:425:7: A
 14151  
                     {
 14152  64
                     A312=(Token)match(input,A,FOLLOW_A_in_pathPrimary3493);  
 14153  64
                     stream_A.add(A312);
 14154  
 
 14155  
 
 14156  
                     // AST REWRITE
 14157  
                     // elements: A
 14158  
                     // token labels: 
 14159  
                     // rule labels: retval
 14160  
                     // token list labels: 
 14161  
                     // rule list labels: 
 14162  
                     // wildcard labels: 
 14163  64
                     retval.tree = root_0;
 14164  64
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14165  
 
 14166  64
                     root_0 = (Object)adaptor.nil();
 14167  
                     // 425:9: -> ^( PATH_PRIMARY A )
 14168  
                     {
 14169  
                         // com\\googlecode\\sparkleg\\Sparql.g:425:12: ^( PATH_PRIMARY A )
 14170  
                         {
 14171  64
                         Object root_1 = (Object)adaptor.nil();
 14172  64
                         root_1 = (Object)adaptor.becomeRoot(
 14173  
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14174  
                         , root_1);
 14175  
 
 14176  64
                         adaptor.addChild(root_1, 
 14177  
                         stream_A.nextNode()
 14178  
                         );
 14179  
 
 14180  64
                         adaptor.addChild(root_0, root_1);
 14181  
                         }
 14182  
 
 14183  
                     }
 14184  
 
 14185  
 
 14186  64
                     retval.tree = root_0;
 14187  
 
 14188  
                     }
 14189  64
                     break;
 14190  
                 case 3 :
 14191  
                     // com\\googlecode\\sparkleg\\Sparql.g:426:7: NEGATION pathNegatedPropertySet
 14192  
                     {
 14193  6
                     NEGATION313=(Token)match(input,NEGATION,FOLLOW_NEGATION_in_pathPrimary3509);  
 14194  6
                     stream_NEGATION.add(NEGATION313);
 14195  
 
 14196  
 
 14197  6
                     pushFollow(FOLLOW_pathNegatedPropertySet_in_pathPrimary3511);
 14198  6
                     pathNegatedPropertySet314=pathNegatedPropertySet();
 14199  
 
 14200  6
                     state._fsp--;
 14201  
 
 14202  6
                     stream_pathNegatedPropertySet.add(pathNegatedPropertySet314.getTree());
 14203  
 
 14204  
                     // AST REWRITE
 14205  
                     // elements: NEGATION, pathNegatedPropertySet
 14206  
                     // token labels: 
 14207  
                     // rule labels: retval
 14208  
                     // token list labels: 
 14209  
                     // rule list labels: 
 14210  
                     // wildcard labels: 
 14211  6
                     retval.tree = root_0;
 14212  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14213  
 
 14214  6
                     root_0 = (Object)adaptor.nil();
 14215  
                     // 426:39: -> ^( PATH_PRIMARY NEGATION pathNegatedPropertySet )
 14216  
                     {
 14217  
                         // com\\googlecode\\sparkleg\\Sparql.g:426:42: ^( PATH_PRIMARY NEGATION pathNegatedPropertySet )
 14218  
                         {
 14219  6
                         Object root_1 = (Object)adaptor.nil();
 14220  6
                         root_1 = (Object)adaptor.becomeRoot(
 14221  
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14222  
                         , root_1);
 14223  
 
 14224  6
                         adaptor.addChild(root_1, 
 14225  
                         stream_NEGATION.nextNode()
 14226  
                         );
 14227  
 
 14228  6
                         adaptor.addChild(root_1, stream_pathNegatedPropertySet.nextTree());
 14229  
 
 14230  6
                         adaptor.addChild(root_0, root_1);
 14231  
                         }
 14232  
 
 14233  
                     }
 14234  
 
 14235  
 
 14236  6
                     retval.tree = root_0;
 14237  
 
 14238  
                     }
 14239  6
                     break;
 14240  
                 case 4 :
 14241  
                     // com\\googlecode\\sparkleg\\Sparql.g:427:7: OPEN_BRACE path CLOSE_BRACE
 14242  
                     {
 14243  20
                     OPEN_BRACE315=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_pathPrimary3529);  
 14244  20
                     stream_OPEN_BRACE.add(OPEN_BRACE315);
 14245  
 
 14246  
 
 14247  20
                     pushFollow(FOLLOW_path_in_pathPrimary3531);
 14248  20
                     path316=path();
 14249  
 
 14250  20
                     state._fsp--;
 14251  
 
 14252  20
                     stream_path.add(path316.getTree());
 14253  
 
 14254  20
                     CLOSE_BRACE317=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_pathPrimary3533);  
 14255  20
                     stream_CLOSE_BRACE.add(CLOSE_BRACE317);
 14256  
 
 14257  
 
 14258  
                     // AST REWRITE
 14259  
                     // elements: path
 14260  
                     // token labels: 
 14261  
                     // rule labels: retval
 14262  
                     // token list labels: 
 14263  
                     // rule list labels: 
 14264  
                     // wildcard labels: 
 14265  20
                     retval.tree = root_0;
 14266  20
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14267  
 
 14268  20
                     root_0 = (Object)adaptor.nil();
 14269  
                     // 427:35: -> ^( PATH_PRIMARY path )
 14270  
                     {
 14271  
                         // com\\googlecode\\sparkleg\\Sparql.g:427:38: ^( PATH_PRIMARY path )
 14272  
                         {
 14273  20
                         Object root_1 = (Object)adaptor.nil();
 14274  20
                         root_1 = (Object)adaptor.becomeRoot(
 14275  
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14276  
                         , root_1);
 14277  
 
 14278  20
                         adaptor.addChild(root_1, stream_path.nextTree());
 14279  
 
 14280  20
                         adaptor.addChild(root_0, root_1);
 14281  
                         }
 14282  
 
 14283  
                     }
 14284  
 
 14285  
 
 14286  20
                     retval.tree = root_0;
 14287  
 
 14288  
                     }
 14289  
                     break;
 14290  
 
 14291  
             }
 14292  2776
             retval.stop = input.LT(-1);
 14293  
 
 14294  
 
 14295  2776
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14296  2776
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14297  
 
 14298  
         }
 14299  0
         catch (RecognitionException re) {
 14300  0
             reportError(re);
 14301  0
             recover(input,re);
 14302  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14303  
 
 14304  
         }
 14305  
 
 14306  0
         finally {
 14307  
                 // do for sure before leaving
 14308  2776
         }
 14309  2776
         return retval;
 14310  
     }
 14311  
     // $ANTLR end "pathPrimary"
 14312  
 
 14313  
 
 14314  6
     public static class pathNegatedPropertySet_return extends ParserRuleReturnScope {
 14315  
         Object tree;
 14316  6
         public Object getTree() { return tree; }
 14317  
     };
 14318  
 
 14319  
 
 14320  
     // $ANTLR start "pathNegatedPropertySet"
 14321  
     // com\\googlecode\\sparkleg\\Sparql.g:430:1: pathNegatedPropertySet : ( pathOneInPropertySet -> ^( PATH_NEGATED pathOneInPropertySet ) | OPEN_BRACE ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )? CLOSE_BRACE -> ^( PATH_NEGATED ( pathOneInPropertySet )+ ) );
 14322  
     public final SparqlParser.pathNegatedPropertySet_return pathNegatedPropertySet() throws RecognitionException {
 14323  6
         SparqlParser.pathNegatedPropertySet_return retval = new SparqlParser.pathNegatedPropertySet_return();
 14324  6
         retval.start = input.LT(1);
 14325  
 
 14326  
 
 14327  6
         Object root_0 = null;
 14328  
 
 14329  6
         Token OPEN_BRACE319=null;
 14330  6
         Token PIPE321=null;
 14331  6
         Token CLOSE_BRACE323=null;
 14332  6
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet318 =null;
 14333  
 
 14334  6
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet320 =null;
 14335  
 
 14336  6
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet322 =null;
 14337  
 
 14338  
 
 14339  6
         Object OPEN_BRACE319_tree=null;
 14340  6
         Object PIPE321_tree=null;
 14341  6
         Object CLOSE_BRACE323_tree=null;
 14342  6
         RewriteRuleTokenStream stream_PIPE=new RewriteRuleTokenStream(adaptor,"token PIPE");
 14343  6
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 14344  6
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 14345  6
         RewriteRuleSubtreeStream stream_pathOneInPropertySet=new RewriteRuleSubtreeStream(adaptor,"rule pathOneInPropertySet");
 14346  
         try {
 14347  
             // com\\googlecode\\sparkleg\\Sparql.g:431:5: ( pathOneInPropertySet -> ^( PATH_NEGATED pathOneInPropertySet ) | OPEN_BRACE ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )? CLOSE_BRACE -> ^( PATH_NEGATED ( pathOneInPropertySet )+ ) )
 14348  3
             int alt108=2;
 14349  3
             switch ( input.LA(1) ) {
 14350  
             case A:
 14351  3
             case INVERSE:
 14352  3
             case IRI_REF:
 14353  
             case PNAME_LN:
 14354  
             case PNAME_NS:
 14355  
                 {
 14356  0
                 alt108=1;
 14357  
                 }
 14358  0
                 break;
 14359  
             case OPEN_BRACE:
 14360  
                 {
 14361  3
                 alt108=2;
 14362  
                 }
 14363  3
                 break;
 14364  3
             default:
 14365  0
                 NoViableAltException nvae =
 14366  3
                     new NoViableAltException("", 108, 0, input);
 14367  
 
 14368  0
                 throw nvae;
 14369  
 
 14370  
             }
 14371  
 
 14372  3
             switch (alt108) {
 14373  
                 case 1 :
 14374  
                     // com\\googlecode\\sparkleg\\Sparql.g:431:7: pathOneInPropertySet
 14375  3
                     {
 14376  0
                     pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3558);
 14377  0
                     pathOneInPropertySet318=pathOneInPropertySet();
 14378  
 
 14379  0
                     state._fsp--;
 14380  
 
 14381  0
                     stream_pathOneInPropertySet.add(pathOneInPropertySet318.getTree());
 14382  
 
 14383  
                     // AST REWRITE
 14384  
                     // elements: pathOneInPropertySet
 14385  
                     // token labels: 
 14386  
                     // rule labels: retval
 14387  
                     // token list labels: 
 14388  
                     // rule list labels: 
 14389  
                     // wildcard labels: 
 14390  0
                     retval.tree = root_0;
 14391  3
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14392  3
 
 14393  0
                     root_0 = (Object)adaptor.nil();
 14394  
                     // 431:28: -> ^( PATH_NEGATED pathOneInPropertySet )
 14395  
                     {
 14396  3
                         // com\\googlecode\\sparkleg\\Sparql.g:431:31: ^( PATH_NEGATED pathOneInPropertySet )
 14397  3
                         {
 14398  0
                         Object root_1 = (Object)adaptor.nil();
 14399  0
                         root_1 = (Object)adaptor.becomeRoot(
 14400  
                         (Object)adaptor.create(PATH_NEGATED, "PATH_NEGATED")
 14401  
                         , root_1);
 14402  
 
 14403  0
                         adaptor.addChild(root_1, stream_pathOneInPropertySet.nextTree());
 14404  3
 
 14405  0
                         adaptor.addChild(root_0, root_1);
 14406  
                         }
 14407  
 
 14408  
                     }
 14409  3
 
 14410  
 
 14411  0
                     retval.tree = root_0;
 14412  
 
 14413  3
                     }
 14414  3
                     break;
 14415  
                 case 2 :
 14416  3
                     // com\\googlecode\\sparkleg\\Sparql.g:432:7: OPEN_BRACE ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )? CLOSE_BRACE
 14417  
                     {
 14418  6
                     OPEN_BRACE319=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_pathNegatedPropertySet3574);  
 14419  3
                     stream_OPEN_BRACE.add(OPEN_BRACE319);
 14420  
 
 14421  
 
 14422  
                     // com\\googlecode\\sparkleg\\Sparql.g:432:18: ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )?
 14423  9
                     int alt107=2;
 14424  9
                     switch ( input.LA(1) ) {
 14425  
                         case A:
 14426  
                         case INVERSE:
 14427  3
                         case IRI_REF:
 14428  
                         case PNAME_LN:
 14429  
                         case PNAME_NS:
 14430  
                             {
 14431  3
                             alt107=1;
 14432  
                             }
 14433  6
                             break;
 14434  
                     }
 14435  
 
 14436  3
                     switch (alt107) {
 14437  3
                         case 1 :
 14438  3
                             // com\\googlecode\\sparkleg\\Sparql.g:432:19: pathOneInPropertySet ( PIPE pathOneInPropertySet )*
 14439  
                             {
 14440  3
                             pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3577);
 14441  6
                             pathOneInPropertySet320=pathOneInPropertySet();
 14442  3
 
 14443  3
                             state._fsp--;
 14444  3
 
 14445  3
                             stream_pathOneInPropertySet.add(pathOneInPropertySet320.getTree());
 14446  3
 
 14447  
                             // com\\googlecode\\sparkleg\\Sparql.g:432:40: ( PIPE pathOneInPropertySet )*
 14448  
                             loop106:
 14449  3
                             do {
 14450  6
                                 int alt106=2;
 14451  6
                                 switch ( input.LA(1) ) {
 14452  3
                                 case PIPE:
 14453  
                                     {
 14454  6
                                     alt106=1;
 14455  
                                     }
 14456  
                                     break;
 14457  
 
 14458  
                                 }
 14459  
 
 14460  6
                                 switch (alt106) {
 14461  
                                     case 1 :
 14462  
                                         // com\\googlecode\\sparkleg\\Sparql.g:432:41: PIPE pathOneInPropertySet
 14463  3
                                         {
 14464  6
                                         PIPE321=(Token)match(input,PIPE,FOLLOW_PIPE_in_pathNegatedPropertySet3580);  
 14465  3
                                         stream_PIPE.add(PIPE321);
 14466  
 
 14467  
 
 14468  3
                                         pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3582);
 14469  3
                                         pathOneInPropertySet322=pathOneInPropertySet();
 14470  
 
 14471  3
                                         state._fsp--;
 14472  
 
 14473  3
                                         stream_pathOneInPropertySet.add(pathOneInPropertySet322.getTree());
 14474  
 
 14475  
                                         }
 14476  3
                                         break;
 14477  
 
 14478  
                                     default :
 14479  3
                                         break loop106;
 14480  3
                                 }
 14481  6
                             } while (true);
 14482  
 
 14483  3
 
 14484  
                             }
 14485  
                             break;
 14486  
 
 14487  
                     }
 14488  3
 
 14489  3
 
 14490  3
                     CLOSE_BRACE323=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_pathNegatedPropertySet3588);  
 14491  3
                     stream_CLOSE_BRACE.add(CLOSE_BRACE323);
 14492  
 
 14493  3
 
 14494  
                     // AST REWRITE
 14495  
                     // elements: pathOneInPropertySet
 14496  9
                     // token labels: 
 14497  6
                     // rule labels: retval
 14498  
                     // token list labels: 
 14499  
                     // rule list labels: 
 14500  3
                     // wildcard labels: 
 14501  3
                     retval.tree = root_0;
 14502  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14503  
 
 14504  3
                     root_0 = (Object)adaptor.nil();
 14505  
                     // 432:83: -> ^( PATH_NEGATED ( pathOneInPropertySet )+ )
 14506  
                     {
 14507  
                         // com\\googlecode\\sparkleg\\Sparql.g:432:86: ^( PATH_NEGATED ( pathOneInPropertySet )+ )
 14508  3
                         {
 14509  3
                         Object root_1 = (Object)adaptor.nil();
 14510  3
                         root_1 = (Object)adaptor.becomeRoot(
 14511  
                         (Object)adaptor.create(PATH_NEGATED, "PATH_NEGATED")
 14512  3
                         , root_1);
 14513  
 
 14514  3
                         if ( !(stream_pathOneInPropertySet.hasNext()) ) {
 14515  3
                             throw new RewriteEarlyExitException();
 14516  3
                         }
 14517  9
                         while ( stream_pathOneInPropertySet.hasNext() ) {
 14518  6
                             adaptor.addChild(root_1, stream_pathOneInPropertySet.nextTree());
 14519  
 
 14520  
                         }
 14521  3
                         stream_pathOneInPropertySet.reset();
 14522  
 
 14523  3
                         adaptor.addChild(root_0, root_1);
 14524  
                         }
 14525  
 
 14526  
                     }
 14527  
 
 14528  3
 
 14529  6
                     retval.tree = root_0;
 14530  
 
 14531  
                     }
 14532  
                     break;
 14533  
 
 14534  6
             }
 14535  3
             retval.stop = input.LT(-1);
 14536  6
 
 14537  
 
 14538  3
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14539  3
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14540  
 
 14541  
         }
 14542  0
         catch (RecognitionException re) {
 14543  6
             reportError(re);
 14544  6
             recover(input,re);
 14545  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14546  
 
 14547  6
         }
 14548  
 
 14549  6
         finally {
 14550  6
                 // do for sure before leaving
 14551  9
         }
 14552  3
         return retval;
 14553  
     }
 14554  6
     // $ANTLR end "pathNegatedPropertySet"
 14555  6
 
 14556  
 
 14557  6
     public static class pathOneInPropertySet_return extends ParserRuleReturnScope {
 14558  
         Object tree;
 14559  6
         public Object getTree() { return tree; }
 14560  
     };
 14561  6
 
 14562  
 
 14563  
     // $ANTLR start "pathOneInPropertySet"
 14564  
     // com\\googlecode\\sparkleg\\Sparql.g:435:1: pathOneInPropertySet : ( INVERSE )? ( iriRef | A ) ;
 14565  6
     public final SparqlParser.pathOneInPropertySet_return pathOneInPropertySet() throws RecognitionException {
 14566  12
         SparqlParser.pathOneInPropertySet_return retval = new SparqlParser.pathOneInPropertySet_return();
 14567  6
         retval.start = input.LT(1);
 14568  
 
 14569  2
 
 14570  6
         Object root_0 = null;
 14571  
 
 14572  6
         Token INVERSE324=null;
 14573  6
         Token A326=null;
 14574  12
         SparqlParser.iriRef_return iriRef325 =null;
 14575  
 
 14576  
 
 14577  6
         Object INVERSE324_tree=null;
 14578  8
         Object A326_tree=null;
 14579  2
 
 14580  
         try {
 14581  
             // com\\googlecode\\sparkleg\\Sparql.g:436:5: ( ( INVERSE )? ( iriRef | A ) )
 14582  2
             // com\\googlecode\\sparkleg\\Sparql.g:436:7: ( INVERSE )? ( iriRef | A )
 14583  
             {
 14584  6
             root_0 = (Object)adaptor.nil();
 14585  
 
 14586  
 
 14587  
             // com\\googlecode\\sparkleg\\Sparql.g:436:7: ( INVERSE )?
 14588  6
             int alt109=2;
 14589  6
             switch ( input.LA(1) ) {
 14590  
                 case INVERSE:
 14591  
                     {
 14592  8
                     alt109=1;
 14593  6
                     }
 14594  
                     break;
 14595  
             }
 14596  
 
 14597  6
             switch (alt109) {
 14598  6
                 case 1 :
 14599  
                     // com\\googlecode\\sparkleg\\Sparql.g:436:7: INVERSE
 14600  6
                     {
 14601  2
                     INVERSE324=(Token)match(input,INVERSE,FOLLOW_INVERSE_in_pathOneInPropertySet3617); 
 14602  2
                     INVERSE324_tree = 
 14603  
                     (Object)adaptor.create(INVERSE324)
 14604  
                     ;
 14605  2
                     adaptor.addChild(root_0, INVERSE324_tree);
 14606  
 
 14607  
 
 14608  
                     }
 14609  
                     break;
 14610  
 
 14611  
             }
 14612  
 
 14613  
 
 14614  6
             // com\\googlecode\\sparkleg\\Sparql.g:436:16: ( iriRef | A )
 14615  6
             int alt110=2;
 14616  6
             switch ( input.LA(1) ) {
 14617  
             case IRI_REF:
 14618  6
             case PNAME_LN:
 14619  6
             case PNAME_NS:
 14620  
                 {
 14621  12
                 alt110=1;
 14622  
                 }
 14623  12
                 break;
 14624  
             case A:
 14625  
                 {
 14626  6
                 alt110=2;
 14627  
                 }
 14628  0
                 break;
 14629  
             default:
 14630  0
                 NoViableAltException nvae =
 14631  
                     new NoViableAltException("", 110, 0, input);
 14632  
 
 14633  0
                 throw nvae;
 14634  
 
 14635  
             }
 14636  
 
 14637  6
             switch (alt110) {
 14638  
                 case 1 :
 14639  
                     // com\\googlecode\\sparkleg\\Sparql.g:436:17: iriRef
 14640  
                     {
 14641  6
                     pushFollow(FOLLOW_iriRef_in_pathOneInPropertySet3621);
 14642  6
                     iriRef325=iriRef();
 14643  
 
 14644  6
                     state._fsp--;
 14645  6
 
 14646  6
                     adaptor.addChild(root_0, iriRef325.getTree());
 14647  
 
 14648  6
                     }
 14649  12
                     break;
 14650  
                 case 2 :
 14651  
                     // com\\googlecode\\sparkleg\\Sparql.g:436:26: A
 14652  
                     {
 14653  0
                     A326=(Token)match(input,A,FOLLOW_A_in_pathOneInPropertySet3625); 
 14654  0
                     A326_tree = 
 14655  
                     (Object)adaptor.create(A326)
 14656  
                     ;
 14657  0
                     adaptor.addChild(root_0, A326_tree);
 14658  
 
 14659  
 
 14660  
                     }
 14661  6
                     break;
 14662  6
 
 14663  
             }
 14664  
 
 14665  
 
 14666  
             }
 14667  29
 
 14668  6
             retval.stop = input.LT(-1);
 14669  29
 
 14670  
 
 14671  6
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14672  6
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14673  
 
 14674  
         }
 14675  0
         catch (RecognitionException re) {
 14676  29
             reportError(re);
 14677  29
             recover(input,re);
 14678  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14679  
 
 14680  29
         }
 14681  
 
 14682  29
         finally {
 14683  29
                 // do for sure before leaving
 14684  35
         }
 14685  35
         return retval;
 14686  29
     }
 14687  
     // $ANTLR end "pathOneInPropertySet"
 14688  29
 
 14689  
 
 14690  29
     public static class triplesNode_return extends ParserRuleReturnScope {
 14691  29
         Object tree;
 14692  29
         public Object getTree() { return tree; }
 14693  29
     };
 14694  29
 
 14695  29
 
 14696  29
     // $ANTLR start "triplesNode"
 14697  29
     // com\\googlecode\\sparkleg\\Sparql.g:439:1: triplesNode : ( OPEN_BRACE ( graphNode )+ CLOSE_BRACE -> ^( COLLECTION ( graphNode )+ ) | OPEN_SQUARE_BRACKET propertyListNotEmpty CLOSE_SQUARE_BRACKET -> ^( TRIPLES_NODE propertyListNotEmpty ) );
 14698  29
     public final SparqlParser.triplesNode_return triplesNode() throws RecognitionException {
 14699  58
         SparqlParser.triplesNode_return retval = new SparqlParser.triplesNode_return();
 14700  58
         retval.start = input.LT(1);
 14701  
 
 14702  
 
 14703  58
         Object root_0 = null;
 14704  29
 
 14705  29
         Token OPEN_BRACE327=null;
 14706  29
         Token CLOSE_BRACE329=null;
 14707  43
         Token OPEN_SQUARE_BRACKET330=null;
 14708  29
         Token CLOSE_SQUARE_BRACKET332=null;
 14709  43
         SparqlParser.graphNode_return graphNode328 =null;
 14710  
 
 14711  29
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty331 =null;
 14712  15
 
 14713  
 
 14714  44
         Object OPEN_BRACE327_tree=null;
 14715  29
         Object CLOSE_BRACE329_tree=null;
 14716  29
         Object OPEN_SQUARE_BRACKET330_tree=null;
 14717  29
         Object CLOSE_SQUARE_BRACKET332_tree=null;
 14718  29
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 14719  29
         RewriteRuleTokenStream stream_OPEN_SQUARE_BRACKET=new RewriteRuleTokenStream(adaptor,"token OPEN_SQUARE_BRACKET");
 14720  29
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 14721  29
         RewriteRuleTokenStream stream_CLOSE_SQUARE_BRACKET=new RewriteRuleTokenStream(adaptor,"token CLOSE_SQUARE_BRACKET");
 14722  29
         RewriteRuleSubtreeStream stream_graphNode=new RewriteRuleSubtreeStream(adaptor,"rule graphNode");
 14723  58
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 14724  
         try {
 14725  
             // com\\googlecode\\sparkleg\\Sparql.g:440:5: ( OPEN_BRACE ( graphNode )+ CLOSE_BRACE -> ^( COLLECTION ( graphNode )+ ) | OPEN_SQUARE_BRACKET propertyListNotEmpty CLOSE_SQUARE_BRACKET -> ^( TRIPLES_NODE propertyListNotEmpty ) )
 14726  29
             int alt112=2;
 14727  43
             switch ( input.LA(1) ) {
 14728  14
             case OPEN_BRACE:
 14729  
                 {
 14730  14
                 alt112=1;
 14731  
                 }
 14732  28
                 break;
 14733  
             case OPEN_SQUARE_BRACKET:
 14734  
                 {
 14735  48
                 alt112=2;
 14736  33
                 }
 14737  15
                 break;
 14738  
             default:
 14739  0
                 NoViableAltException nvae =
 14740  
                     new NoViableAltException("", 112, 0, input);
 14741  
 
 14742  0
                 throw nvae;
 14743  
 
 14744  
             }
 14745  
 
 14746  29
             switch (alt112) {
 14747  
                 case 1 :
 14748  
                     // com\\googlecode\\sparkleg\\Sparql.g:440:7: OPEN_BRACE ( graphNode )+ CLOSE_BRACE
 14749  
                     {
 14750  14
                     OPEN_BRACE327=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_triplesNode3644);  
 14751  14
                     stream_OPEN_BRACE.add(OPEN_BRACE327);
 14752  
 
 14753  
 
 14754  
                     // com\\googlecode\\sparkleg\\Sparql.g:440:18: ( graphNode )+
 14755  14
                     int cnt111=0;
 14756  
                     loop111:
 14757  
                     do {
 14758  33
                         int alt111=2;
 14759  33
                         switch ( input.LA(1) ) {
 14760  
                         case BLANK_NODE_LABEL:
 14761  19
                         case DECIMAL:
 14762  
                         case DECIMAL_NEGATIVE:
 14763  
                         case DECIMAL_POSITIVE:
 14764  
                         case DOUBLE:
 14765  
                         case DOUBLE_NEGATIVE:
 14766  
                         case DOUBLE_POSITIVE:
 14767  33
                         case FALSE:
 14768  
                         case INTEGER:
 14769  
                         case INTEGER_NEGATIVE:
 14770  
                         case INTEGER_POSITIVE:
 14771  19
                         case IRI_REF:
 14772  19
                         case OPEN_BRACE:
 14773  
                         case OPEN_SQUARE_BRACKET:
 14774  19
                         case PNAME_LN:
 14775  
                         case PNAME_NS:
 14776  19
                         case STRING_LITERAL1:
 14777  
                         case STRING_LITERAL2:
 14778  
                         case STRING_LITERAL_LONG1:
 14779  19
                         case STRING_LITERAL_LONG2:
 14780  
                         case TRUE:
 14781  
                         case VAR1:
 14782  14
                         case VAR2:
 14783  
                             {
 14784  19
                             alt111=1;
 14785  
                             }
 14786  
                             break;
 14787  19
 
 14788  19
                         }
 14789  
 
 14790  33
                         switch (alt111) {
 14791  14
                             case 1 :
 14792  14
                                 // com\\googlecode\\sparkleg\\Sparql.g:440:18: graphNode
 14793  
                                 {
 14794  19
                                 pushFollow(FOLLOW_graphNode_in_triplesNode3646);
 14795  19
                                 graphNode328=graphNode();
 14796  
 
 14797  19
                                 state._fsp--;
 14798  
 
 14799  19
                                 stream_graphNode.add(graphNode328.getTree());
 14800  
 
 14801  
                                 }
 14802  33
                                 break;
 14803  14
 
 14804  
                             default :
 14805  28
                                 if ( cnt111 >= 1 ) break loop111;
 14806  0
                                 EarlyExitException eee =
 14807  
                                     new EarlyExitException(111, input);
 14808  0
                                 throw eee;
 14809  
                         }
 14810  33
                         cnt111++;
 14811  33
                     } while (true);
 14812  
 
 14813  
 
 14814  14
                     CLOSE_BRACE329=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_triplesNode3649);  
 14815  28
                     stream_CLOSE_BRACE.add(CLOSE_BRACE329);
 14816  
 
 14817  
 
 14818  33
                     // AST REWRITE
 14819  19
                     // elements: graphNode
 14820  
                     // token labels: 
 14821  
                     // rule labels: retval
 14822  14
                     // token list labels: 
 14823  
                     // rule list labels: 
 14824  14
                     // wildcard labels: 
 14825  14
                     retval.tree = root_0;
 14826  14
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14827  
 
 14828  14
                     root_0 = (Object)adaptor.nil();
 14829  
                     // 440:41: -> ^( COLLECTION ( graphNode )+ )
 14830  14
                     {
 14831  
                         // com\\googlecode\\sparkleg\\Sparql.g:440:44: ^( COLLECTION ( graphNode )+ )
 14832  
                         {
 14833  28
                         Object root_1 = (Object)adaptor.nil();
 14834  14
                         root_1 = (Object)adaptor.becomeRoot(
 14835  
                         (Object)adaptor.create(COLLECTION, "COLLECTION")
 14836  
                         , root_1);
 14837  15
 
 14838  29
                         if ( !(stream_graphNode.hasNext()) ) {
 14839  0
                             throw new RewriteEarlyExitException();
 14840  
                         }
 14841  48
                         while ( stream_graphNode.hasNext() ) {
 14842  34
                             adaptor.addChild(root_1, stream_graphNode.nextTree());
 14843  
 
 14844  15
                         }
 14845  14
                         stream_graphNode.reset();
 14846  15
 
 14847  14
                         adaptor.addChild(root_0, root_1);
 14848  15
                         }
 14849  15
 
 14850  
                     }
 14851  
 
 14852  
 
 14853  14
                     retval.tree = root_0;
 14854  
 
 14855  
                     }
 14856  14
                     break;
 14857  
                 case 2 :
 14858  
                     // com\\googlecode\\sparkleg\\Sparql.g:441:7: OPEN_SQUARE_BRACKET propertyListNotEmpty CLOSE_SQUARE_BRACKET
 14859  15
                     {
 14860  30
                     OPEN_SQUARE_BRACKET330=(Token)match(input,OPEN_SQUARE_BRACKET,FOLLOW_OPEN_SQUARE_BRACKET_in_triplesNode3666);  
 14861  15
                     stream_OPEN_SQUARE_BRACKET.add(OPEN_SQUARE_BRACKET330);
 14862  15
 
 14863  
 
 14864  15
                     pushFollow(FOLLOW_propertyListNotEmpty_in_triplesNode3668);
 14865  15
                     propertyListNotEmpty331=propertyListNotEmpty();
 14866  
 
 14867  30
                     state._fsp--;
 14868  15
 
 14869  15
                     stream_propertyListNotEmpty.add(propertyListNotEmpty331.getTree());
 14870  
 
 14871  15
                     CLOSE_SQUARE_BRACKET332=(Token)match(input,CLOSE_SQUARE_BRACKET,FOLLOW_CLOSE_SQUARE_BRACKET_in_triplesNode3670);  
 14872  30
                     stream_CLOSE_SQUARE_BRACKET.add(CLOSE_SQUARE_BRACKET332);
 14873  
 
 14874  15
 
 14875  
                     // AST REWRITE
 14876  
                     // elements: propertyListNotEmpty
 14877  
                     // token labels: 
 14878  
                     // rule labels: retval
 14879  
                     // token list labels: 
 14880  15
                     // rule list labels: 
 14881  
                     // wildcard labels: 
 14882  15
                     retval.tree = root_0;
 14883  15
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14884  
 
 14885  15
                     root_0 = (Object)adaptor.nil();
 14886  29
                     // 441:69: -> ^( TRIPLES_NODE propertyListNotEmpty )
 14887  
                     {
 14888  
                         // com\\googlecode\\sparkleg\\Sparql.g:441:72: ^( TRIPLES_NODE propertyListNotEmpty )
 14889  29
                         {
 14890  44
                         Object root_1 = (Object)adaptor.nil();
 14891  15
                         root_1 = (Object)adaptor.becomeRoot(
 14892  
                         (Object)adaptor.create(TRIPLES_NODE, "TRIPLES_NODE")
 14893  
                         , root_1);
 14894  
 
 14895  15
                         adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 14896  
 
 14897  15
                         adaptor.addChild(root_0, root_1);
 14898  
                         }
 14899  
 
 14900  
                     }
 14901  
 
 14902  29
 
 14903  44
                     retval.tree = root_0;
 14904  
 
 14905  
                     }
 14906  
                     break;
 14907  
 
 14908  1723
             }
 14909  29
             retval.stop = input.LT(-1);
 14910  1723
 
 14911  
 
 14912  29
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14913  29
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14914  
 
 14915  
         }
 14916  0
         catch (RecognitionException re) {
 14917  1723
             reportError(re);
 14918  1723
             recover(input,re);
 14919  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14920  
 
 14921  1723
         }
 14922  
 
 14923  1723
         finally {
 14924  
                 // do for sure before leaving
 14925  1752
         }
 14926  29
         return retval;
 14927  
     }
 14928  
     // $ANTLR end "triplesNode"
 14929  
 
 14930  
 
 14931  1723
     public static class graphNode_return extends ParserRuleReturnScope {
 14932  1723
         Object tree;
 14933  1723
         public Object getTree() { return tree; }
 14934  
     };
 14935  
 
 14936  
 
 14937  
     // $ANTLR start "graphNode"
 14938  
     // com\\googlecode\\sparkleg\\Sparql.g:444:1: graphNode : ( varOrTerm | triplesNode );
 14939  
     public final SparqlParser.graphNode_return graphNode() throws RecognitionException {
 14940  1723
         SparqlParser.graphNode_return retval = new SparqlParser.graphNode_return();
 14941  1723
         retval.start = input.LT(1);
 14942  
 
 14943  
 
 14944  1723
         Object root_0 = null;
 14945  
 
 14946  1723
         SparqlParser.varOrTerm_return varOrTerm333 =null;
 14947  
 
 14948  1723
         SparqlParser.triplesNode_return triplesNode334 =null;
 14949  
 
 14950  
 
 14951  
 
 14952  
         try {
 14953  
             // com\\googlecode\\sparkleg\\Sparql.g:445:5: ( varOrTerm | triplesNode )
 14954  1723
             int alt113=2;
 14955  3402
             switch ( input.LA(1) ) {
 14956  
             case BLANK_NODE_LABEL:
 14957  1679
             case DECIMAL:
 14958  
             case DECIMAL_NEGATIVE:
 14959  
             case DECIMAL_POSITIVE:
 14960  22
             case DOUBLE:
 14961  
             case DOUBLE_NEGATIVE:
 14962  
             case DOUBLE_POSITIVE:
 14963  12
             case FALSE:
 14964  
             case INTEGER:
 14965  12
             case INTEGER_NEGATIVE:
 14966  
             case INTEGER_POSITIVE:
 14967  
             case IRI_REF:
 14968  
             case PNAME_LN:
 14969  
             case PNAME_NS:
 14970  
             case STRING_LITERAL1:
 14971  
             case STRING_LITERAL2:
 14972  
             case STRING_LITERAL_LONG1:
 14973  
             case STRING_LITERAL_LONG2:
 14974  
             case TRUE:
 14975  
             case VAR1:
 14976  10
             case VAR2:
 14977  
                 {
 14978  1689
                 alt113=1;
 14979  
                 }
 14980  1679
                 break;
 14981  
             case OPEN_SQUARE_BRACKET:
 14982  
                 {
 14983  22
                 switch ( input.LA(2) ) {
 14984  
                 case CLOSE_SQUARE_BRACKET:
 14985  
                     {
 14986  12
                     alt113=1;
 14987  
                     }
 14988  34
                     break;
 14989  
                 case A:
 14990  
                 case INVERSE:
 14991  8
                 case IRI_REF:
 14992  
                 case NEGATION:
 14993  
                 case OPEN_BRACE:
 14994  2
                 case PNAME_LN:
 14995  
                 case PNAME_NS:
 14996  2
                 case VAR1:
 14997  
                 case VAR2:
 14998  
                     {
 14999  10
                     alt113=2;
 15000  
                     }
 15001  10
                     break;
 15002  
                 default:
 15003  0
                     NoViableAltException nvae =
 15004  
                         new NoViableAltException("", 113, 2, input);
 15005  
 
 15006  0
                     throw nvae;
 15007  
 
 15008  
                 }
 15009  
 
 15010  
                 }
 15011  22
                 break;
 15012  
             case OPEN_BRACE:
 15013  
                 {
 15014  8
                 switch ( input.LA(2) ) {
 15015  
                 case CLOSE_BRACE:
 15016  
                     {
 15017  2
                     alt113=1;
 15018  
                     }
 15019  2
                     break;
 15020  
                 case BLANK_NODE_LABEL:
 15021  6
                 case DECIMAL:
 15022  
                 case DECIMAL_NEGATIVE:
 15023  6
                 case DECIMAL_POSITIVE:
 15024  
                 case DOUBLE:
 15025  
                 case DOUBLE_NEGATIVE:
 15026  
                 case DOUBLE_POSITIVE:
 15027  
                 case FALSE:
 15028  
                 case INTEGER:
 15029  
                 case INTEGER_NEGATIVE:
 15030  
                 case INTEGER_POSITIVE:
 15031  
                 case IRI_REF:
 15032  
                 case OPEN_BRACE:
 15033  8
                 case OPEN_SQUARE_BRACKET:
 15034  
                 case PNAME_LN:
 15035  14
                 case PNAME_NS:
 15036  
                 case STRING_LITERAL1:
 15037  
                 case STRING_LITERAL2:
 15038  14
                 case STRING_LITERAL_LONG1:
 15039  
                 case STRING_LITERAL_LONG2:
 15040  
                 case TRUE:
 15041  
                 case VAR1:
 15042  1709
                 case VAR2:
 15043  
                     {
 15044  6
                     alt113=2;
 15045  
                     }
 15046  1699
                     break;
 15047  
                 default:
 15048  0
                     NoViableAltException nvae =
 15049  1693
                         new NoViableAltException("", 113, 3, input);
 15050  1693
 
 15051  0
                     throw nvae;
 15052  1693
 
 15053  
                 }
 15054  1693
 
 15055  
                 }
 15056  8
                 break;
 15057  1693
             default:
 15058  14
                 NoViableAltException nvae =
 15059  
                     new NoViableAltException("", 113, 0, input);
 15060  
 
 15061  30
                 throw nvae;
 15062  
 
 15063  
             }
 15064  16
 
 15065  1725
             switch (alt113) {
 15066  
                 case 1 :
 15067  16
                     // com\\googlecode\\sparkleg\\Sparql.g:445:7: varOrTerm
 15068  
                     {
 15069  1709
                     root_0 = (Object)adaptor.nil();
 15070  
 
 15071  
 
 15072  1693
                     pushFollow(FOLLOW_varOrTerm_in_graphNode3695);
 15073  1693
                     varOrTerm333=varOrTerm();
 15074  
 
 15075  3402
                     state._fsp--;
 15076  
 
 15077  1693
                     adaptor.addChild(root_0, varOrTerm333.getTree());
 15078  1709
 
 15079  1709
                     }
 15080  1693
                     break;
 15081  
                 case 2 :
 15082  14
                     // com\\googlecode\\sparkleg\\Sparql.g:445:19: triplesNode
 15083  14
                     {
 15084  30
                     root_0 = (Object)adaptor.nil();
 15085  14
 
 15086  
 
 15087  16
                     pushFollow(FOLLOW_triplesNode_in_graphNode3699);
 15088  16
                     triplesNode334=triplesNode();
 15089  
 
 15090  16
                     state._fsp--;
 15091  1723
 
 15092  1739
                     adaptor.addChild(root_0, triplesNode334.getTree());
 15093  
 
 15094  
                     }
 15095  
                     break;
 15096  
 
 15097  3257
             }
 15098  1709
             retval.stop = input.LT(-1);
 15099  3257
 
 15100  
 
 15101  1709
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15102  1709
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15103  
 
 15104  
         }
 15105  14
         catch (RecognitionException re) {
 15106  3271
             reportError(re);
 15107  3271
             recover(input,re);
 15108  14
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15109  
 
 15110  3257
         }
 15111  
 
 15112  3257
         finally {
 15113  
                 // do for sure before leaving
 15114  4980
         }
 15115  1723
         return retval;
 15116  
     }
 15117  
     // $ANTLR end "graphNode"
 15118  
 
 15119  
 
 15120  3257
     public static class varOrTerm_return extends ParserRuleReturnScope {
 15121  3257
         Object tree;
 15122  3257
         public Object getTree() { return tree; }
 15123  
     };
 15124  
 
 15125  2468
 
 15126  
     // $ANTLR start "varOrTerm"
 15127  2468
     // com\\googlecode\\sparkleg\\Sparql.g:448:1: varOrTerm : ( var | graphTerm );
 15128  
     public final SparqlParser.varOrTerm_return varOrTerm() throws RecognitionException {
 15129  3257
         SparqlParser.varOrTerm_return retval = new SparqlParser.varOrTerm_return();
 15130  3257
         retval.start = input.LT(1);
 15131  
 
 15132  
 
 15133  3257
         Object root_0 = null;
 15134  
 
 15135  3257
         SparqlParser.var_return var335 =null;
 15136  
 
 15137  3257
         SparqlParser.graphTerm_return graphTerm336 =null;
 15138  
 
 15139  
 
 15140  
 
 15141  
         try {
 15142  
             // com\\googlecode\\sparkleg\\Sparql.g:449:5: ( var | graphTerm )
 15143  3257
             int alt114=2;
 15144  3257
             switch ( input.LA(1) ) {
 15145  
             case VAR1:
 15146  
             case VAR2:
 15147  
                 {
 15148  2468
                 alt114=1;
 15149  
                 }
 15150  3257
                 break;
 15151  
             case BLANK_NODE_LABEL:
 15152  789
             case DECIMAL:
 15153  
             case DECIMAL_NEGATIVE:
 15154  
             case DECIMAL_POSITIVE:
 15155  
             case DOUBLE:
 15156  
             case DOUBLE_NEGATIVE:
 15157  
             case DOUBLE_POSITIVE:
 15158  
             case FALSE:
 15159  
             case INTEGER:
 15160  
             case INTEGER_NEGATIVE:
 15161  3257
             case INTEGER_POSITIVE:
 15162  
             case IRI_REF:
 15163  
             case OPEN_BRACE:
 15164  
             case OPEN_SQUARE_BRACKET:
 15165  2468
             case PNAME_LN:
 15166  
             case PNAME_NS:
 15167  
             case STRING_LITERAL1:
 15168  2468
             case STRING_LITERAL2:
 15169  2468
             case STRING_LITERAL_LONG1:
 15170  
             case STRING_LITERAL_LONG2:
 15171  2468
             case TRUE:
 15172  
                 {
 15173  3257
                 alt114=2;
 15174  
                 }
 15175  789
                 break;
 15176  2468
             default:
 15177  0
                 NoViableAltException nvae =
 15178  
                     new NoViableAltException("", 114, 0, input);
 15179  
 
 15180  789
                 throw nvae;
 15181  
 
 15182  
             }
 15183  789
 
 15184  4046
             switch (alt114) {
 15185  
                 case 1 :
 15186  789
                     // com\\googlecode\\sparkleg\\Sparql.g:449:7: var
 15187  
                     {
 15188  3257
                     root_0 = (Object)adaptor.nil();
 15189  
 
 15190  
 
 15191  2468
                     pushFollow(FOLLOW_var_in_varOrTerm3716);
 15192  2468
                     var335=var();
 15193  
 
 15194  5725
                     state._fsp--;
 15195  
 
 15196  2468
                     adaptor.addChild(root_0, var335.getTree());
 15197  3257
 
 15198  3257
                     }
 15199  2468
                     break;
 15200  
                 case 2 :
 15201  
                     // com\\googlecode\\sparkleg\\Sparql.g:450:7: graphTerm
 15202  
                     {
 15203  789
                     root_0 = (Object)adaptor.nil();
 15204  
 
 15205  
 
 15206  789
                     pushFollow(FOLLOW_graphTerm_in_varOrTerm3724);
 15207  789
                     graphTerm336=graphTerm();
 15208  
 
 15209  789
                     state._fsp--;
 15210  3257
 
 15211  4046
                     adaptor.addChild(root_0, graphTerm336.getTree());
 15212  
 
 15213  
                     }
 15214  
                     break;
 15215  
 
 15216  129
             }
 15217  3257
             retval.stop = input.LT(-1);
 15218  150
 
 15219  
 
 15220  3257
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15221  3257
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15222  
 
 15223  
         }
 15224  0
         catch (RecognitionException re) {
 15225  129
             reportError(re);
 15226  129
             recover(input,re);
 15227  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15228  
 
 15229  129
         }
 15230  
 
 15231  129
         finally {
 15232  
                 // do for sure before leaving
 15233  3386
         }
 15234  3257
         return retval;
 15235  
     }
 15236  
     // $ANTLR end "varOrTerm"
 15237  
 
 15238  
 
 15239  129
     public static class varOrIRIref_return extends ParserRuleReturnScope {
 15240  129
         Object tree;
 15241  150
         public Object getTree() { return tree; }
 15242  
     };
 15243  
 
 15244  73
 
 15245  
     // $ANTLR start "varOrIRIref"
 15246  73
     // com\\googlecode\\sparkleg\\Sparql.g:453:1: varOrIRIref : ( var | iriRef );
 15247  
     public final SparqlParser.varOrIRIref_return varOrIRIref() throws RecognitionException {
 15248  129
         SparqlParser.varOrIRIref_return retval = new SparqlParser.varOrIRIref_return();
 15249  129
         retval.start = input.LT(1);
 15250  
 
 15251  55
 
 15252  129
         Object root_0 = null;
 15253  55
 
 15254  129
         SparqlParser.var_return var337 =null;
 15255  1
 
 15256  129
         SparqlParser.iriRef_return iriRef338 =null;
 15257  
 
 15258  1
 
 15259  
 
 15260  
         try {
 15261  
             // com\\googlecode\\sparkleg\\Sparql.g:454:5: ( var | iriRef )
 15262  257
             int alt115=2;
 15263  129
             switch ( input.LA(1) ) {
 15264  
             case VAR1:
 15265  
             case VAR2:
 15266  73
                 {
 15267  73
                 alt115=1;
 15268  
                 }
 15269  146
                 break;
 15270  73
             case IRI_REF:
 15271  
             case PNAME_LN:
 15272  73
             case PNAME_NS:
 15273  
                 {
 15274  128
                 alt115=2;
 15275  
                 }
 15276  55
                 break;
 15277  73
             default:
 15278  1
                 NoViableAltException nvae =
 15279  
                     new NoViableAltException("", 115, 0, input);
 15280  
 
 15281  56
                 throw nvae;
 15282  
 
 15283  
             }
 15284  55
 
 15285  183
             switch (alt115) {
 15286  
                 case 1 :
 15287  55
                     // com\\googlecode\\sparkleg\\Sparql.g:454:7: var
 15288  
                     {
 15289  128
                     root_0 = (Object)adaptor.nil();
 15290  
 
 15291  
 
 15292  73
                     pushFollow(FOLLOW_var_in_varOrIRIref3741);
 15293  73
                     var337=var();
 15294  
 
 15295  201
                     state._fsp--;
 15296  
 
 15297  73
                     adaptor.addChild(root_0, var337.getTree());
 15298  128
 
 15299  128
                     }
 15300  73
                     break;
 15301  
                 case 2 :
 15302  1
                     // com\\googlecode\\sparkleg\\Sparql.g:454:13: iriRef
 15303  1
                     {
 15304  56
                     root_0 = (Object)adaptor.nil();
 15305  1
 
 15306  
 
 15307  55
                     pushFollow(FOLLOW_iriRef_in_varOrIRIref3745);
 15308  55
                     iriRef338=iriRef();
 15309  
 
 15310  55
                     state._fsp--;
 15311  129
 
 15312  184
                     adaptor.addChild(root_0, iriRef338.getTree());
 15313  
 
 15314  
                     }
 15315  
                     break;
 15316  
 
 15317  4467
             }
 15318  128
             retval.stop = input.LT(-1);
 15319  4467
 
 15320  
 
 15321  128
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15322  128
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15323  
 
 15324  
         }
 15325  1
         catch (RecognitionException re) {
 15326  4468
             reportError(re);
 15327  4468
             recover(input,re);
 15328  1
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15329  
 
 15330  4467
         }
 15331  
 
 15332  4467
         finally {
 15333  
                 // do for sure before leaving
 15334  4596
         }
 15335  129
         return retval;
 15336  
     }
 15337  
     // $ANTLR end "varOrIRIref"
 15338  
 
 15339  
 
 15340  4467
     public static class var_return extends ParserRuleReturnScope {
 15341  
         Object tree;
 15342  4467
         public Object getTree() { return tree; }
 15343  4467
     };
 15344  
 
 15345  4467
 
 15346  4467
     // $ANTLR start "var"
 15347  4467
     // com\\googlecode\\sparkleg\\Sparql.g:457:1: var : ( VAR1 | VAR2 );
 15348  
     public final SparqlParser.var_return var() throws RecognitionException {
 15349  4467
         SparqlParser.var_return retval = new SparqlParser.var_return();
 15350  8934
         retval.start = input.LT(1);
 15351  
 
 15352  
 
 15353  4467
         Object root_0 = null;
 15354  
 
 15355  4467
         Token set339=null;
 15356  
 
 15357  4467
         Object set339_tree=null;
 15358  
 
 15359  
         try {
 15360  4467
             // com\\googlecode\\sparkleg\\Sparql.g:458:5: ( VAR1 | VAR2 )
 15361  
             // com\\googlecode\\sparkleg\\Sparql.g:
 15362  
             {
 15363  8934
             root_0 = (Object)adaptor.nil();
 15364  4467
 
 15365  
 
 15366  4467
             set339=(Token)input.LT(1);
 15367  
 
 15368  4467
             if ( (input.LA(1) >= VAR1 && input.LA(1) <= VAR2) ) {
 15369  4467
                 input.consume();
 15370  4467
                 adaptor.addChild(root_0, 
 15371  
                 (Object)adaptor.create(set339)
 15372  
                 );
 15373  4467
                 state.errorRecovery=false;
 15374  
             }
 15375  
             else {
 15376  4467
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 15377  4467
                 throw mse;
 15378  
             }
 15379  
 
 15380  
 
 15381  
             }
 15382  789
 
 15383  4467
             retval.stop = input.LT(-1);
 15384  789
 
 15385  
 
 15386  4467
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15387  4467
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15388  
 
 15389  
         }
 15390  0
         catch (RecognitionException re) {
 15391  789
             reportError(re);
 15392  789
             recover(input,re);
 15393  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15394  
 
 15395  789
         }
 15396  
 
 15397  789
         finally {
 15398  
                 // do for sure before leaving
 15399  5256
         }
 15400  4467
         return retval;
 15401  789
     }
 15402  
     // $ANTLR end "var"
 15403  789
 
 15404  
 
 15405  789
     public static class graphTerm_return extends ParserRuleReturnScope {
 15406  
         Object tree;
 15407  789
         public Object getTree() { return tree; }
 15408  
     };
 15409  
 
 15410  
 
 15411  
     // $ANTLR start "graphTerm"
 15412  
     // com\\googlecode\\sparkleg\\Sparql.g:461:1: graphTerm : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil );
 15413  789
     public final SparqlParser.graphTerm_return graphTerm() throws RecognitionException {
 15414  1578
         SparqlParser.graphTerm_return retval = new SparqlParser.graphTerm_return();
 15415  789
         retval.start = input.LT(1);
 15416  
 
 15417  
 
 15418  789
         Object root_0 = null;
 15419  552
 
 15420  789
         SparqlParser.iriRef_return iriRef340 =null;
 15421  552
 
 15422  789
         SparqlParser.rdfLiteral_return rdfLiteral341 =null;
 15423  
 
 15424  789
         SparqlParser.numericLiteral_return numericLiteral342 =null;
 15425  
 
 15426  789
         SparqlParser.booleanLiteral_return booleanLiteral343 =null;
 15427  78
 
 15428  789
         SparqlParser.blankNode_return blankNode344 =null;
 15429  78
 
 15430  789
         SparqlParser.nil_return nil345 =null;
 15431  
 
 15432  
 
 15433  
 
 15434  
         try {
 15435  
             // com\\googlecode\\sparkleg\\Sparql.g:462:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil )
 15436  789
             int alt116=6;
 15437  789
             switch ( input.LA(1) ) {
 15438  
             case IRI_REF:
 15439  
             case PNAME_LN:
 15440  48
             case PNAME_NS:
 15441  
                 {
 15442  600
                 alt116=1;
 15443  
                 }
 15444  552
                 break;
 15445  
             case STRING_LITERAL1:
 15446  2
             case STRING_LITERAL2:
 15447  
             case STRING_LITERAL_LONG1:
 15448  2
             case STRING_LITERAL_LONG2:
 15449  
                 {
 15450  78
                 alt116=2;
 15451  
                 }
 15452  180
                 break;
 15453  
             case DECIMAL:
 15454  102
             case DECIMAL_NEGATIVE:
 15455  
             case DECIMAL_POSITIVE:
 15456  
             case DOUBLE:
 15457  7
             case DOUBLE_NEGATIVE:
 15458  
             case DOUBLE_POSITIVE:
 15459  7
             case INTEGER:
 15460  
             case INTEGER_NEGATIVE:
 15461  
             case INTEGER_POSITIVE:
 15462  
                 {
 15463  48
                 alt116=3;
 15464  
                 }
 15465  48
                 break;
 15466  
             case FALSE:
 15467  
             case TRUE:
 15468  789
                 {
 15469  2
                 alt116=4;
 15470  
                 }
 15471  2
                 break;
 15472  552
             case BLANK_NODE_LABEL:
 15473  
             case OPEN_SQUARE_BRACKET:
 15474  
                 {
 15475  654
                 alt116=5;
 15476  552
                 }
 15477  102
                 break;
 15478  552
             case OPEN_BRACE:
 15479  
                 {
 15480  559
                 alt116=6;
 15481  
                 }
 15482  7
                 break;
 15483  552
             default:
 15484  0
                 NoViableAltException nvae =
 15485  
                     new NoViableAltException("", 116, 0, input);
 15486  
 
 15487  78
                 throw nvae;
 15488  
 
 15489  
             }
 15490  78
 
 15491  867
             switch (alt116) {
 15492  
                 case 1 :
 15493  78
                     // com\\googlecode\\sparkleg\\Sparql.g:462:7: iriRef
 15494  
                     {
 15495  630
                     root_0 = (Object)adaptor.nil();
 15496  
 
 15497  
 
 15498  630
                     pushFollow(FOLLOW_iriRef_in_graphTerm3783);
 15499  552
                     iriRef340=iriRef();
 15500  
 
 15501  552
                     state._fsp--;
 15502  48
 
 15503  552
                     adaptor.addChild(root_0, iriRef340.getTree());
 15504  
 
 15505  48
                     }
 15506  600
                     break;
 15507  
                 case 2 :
 15508  48
                     // com\\googlecode\\sparkleg\\Sparql.g:463:7: rdfLiteral
 15509  
                     {
 15510  126
                     root_0 = (Object)adaptor.nil();
 15511  
 
 15512  
 
 15513  126
                     pushFollow(FOLLOW_rdfLiteral_in_graphTerm3791);
 15514  78
                     rdfLiteral341=rdfLiteral();
 15515  
 
 15516  78
                     state._fsp--;
 15517  2
 
 15518  78
                     adaptor.addChild(root_0, rdfLiteral341.getTree());
 15519  
 
 15520  2
                     }
 15521  80
                     break;
 15522  
                 case 3 :
 15523  2
                     // com\\googlecode\\sparkleg\\Sparql.g:464:7: numericLiteral
 15524  
                     {
 15525  50
                     root_0 = (Object)adaptor.nil();
 15526  
 
 15527  
 
 15528  50
                     pushFollow(FOLLOW_numericLiteral_in_graphTerm3799);
 15529  48
                     numericLiteral342=numericLiteral();
 15530  
 
 15531  48
                     state._fsp--;
 15532  102
 
 15533  48
                     adaptor.addChild(root_0, numericLiteral342.getTree());
 15534  
 
 15535  102
                     }
 15536  150
                     break;
 15537  
                 case 4 :
 15538  102
                     // com\\googlecode\\sparkleg\\Sparql.g:465:7: booleanLiteral
 15539  
                     {
 15540  104
                     root_0 = (Object)adaptor.nil();
 15541  
 
 15542  
 
 15543  104
                     pushFollow(FOLLOW_booleanLiteral_in_graphTerm3807);
 15544  2
                     booleanLiteral343=booleanLiteral();
 15545  
 
 15546  2
                     state._fsp--;
 15547  7
 
 15548  2
                     adaptor.addChild(root_0, booleanLiteral343.getTree());
 15549  
 
 15550  7
                     }
 15551  9
                     break;
 15552  
                 case 5 :
 15553  7
                     // com\\googlecode\\sparkleg\\Sparql.g:466:7: blankNode
 15554  
                     {
 15555  109
                     root_0 = (Object)adaptor.nil();
 15556  
 
 15557  
 
 15558  102
                     pushFollow(FOLLOW_blankNode_in_graphTerm3815);
 15559  102
                     blankNode344=blankNode();
 15560  
 
 15561  891
                     state._fsp--;
 15562  
 
 15563  102
                     adaptor.addChild(root_0, blankNode344.getTree());
 15564  789
 
 15565  789
                     }
 15566  102
                     break;
 15567  
                 case 6 :
 15568  
                     // com\\googlecode\\sparkleg\\Sparql.g:467:7: nil
 15569  
                     {
 15570  7
                     root_0 = (Object)adaptor.nil();
 15571  
 
 15572  
 
 15573  7
                     pushFollow(FOLLOW_nil_in_graphTerm3823);
 15574  7
                     nil345=nil();
 15575  
 
 15576  7
                     state._fsp--;
 15577  789
 
 15578  796
                     adaptor.addChild(root_0, nil345.getTree());
 15579  
 
 15580  
                     }
 15581  
                     break;
 15582  
 
 15583  15
             }
 15584  789
             retval.stop = input.LT(-1);
 15585  15
 
 15586  
 
 15587  789
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15588  789
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15589  
 
 15590  
         }
 15591  0
         catch (RecognitionException re) {
 15592  15
             reportError(re);
 15593  15
             recover(input,re);
 15594  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15595  
 
 15596  15
         }
 15597  
 
 15598  15
         finally {
 15599  15
                 // do for sure before leaving
 15600  789
         }
 15601  804
         return retval;
 15602  15
     }
 15603  
     // $ANTLR end "graphTerm"
 15604  
 
 15605  
 
 15606  15
     public static class nil_return extends ParserRuleReturnScope {
 15607  
         Object tree;
 15608  15
         public Object getTree() { return tree; }
 15609  
     };
 15610  
 
 15611  15
 
 15612  15
     // $ANTLR start "nil"
 15613  
     // com\\googlecode\\sparkleg\\Sparql.g:470:1: nil : OPEN_BRACE CLOSE_BRACE ;
 15614  
     public final SparqlParser.nil_return nil() throws RecognitionException {
 15615  30
         SparqlParser.nil_return retval = new SparqlParser.nil_return();
 15616  15
         retval.start = input.LT(1);
 15617  
 
 15618  15
 
 15619  30
         Object root_0 = null;
 15620  
 
 15621  15
         Token OPEN_BRACE346=null;
 15622  30
         Token CLOSE_BRACE347=null;
 15623  
 
 15624  15
         Object OPEN_BRACE346_tree=null;
 15625  15
         Object CLOSE_BRACE347_tree=null;
 15626  
 
 15627  15
         try {
 15628  
             // com\\googlecode\\sparkleg\\Sparql.g:471:5: ( OPEN_BRACE CLOSE_BRACE )
 15629  
             // com\\googlecode\\sparkleg\\Sparql.g:471:7: OPEN_BRACE CLOSE_BRACE
 15630  15
             {
 15631  30
             root_0 = (Object)adaptor.nil();
 15632  
 
 15633  
 
 15634  15
             OPEN_BRACE346=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_nil3844); 
 15635  15
             OPEN_BRACE346_tree = 
 15636  
             (Object)adaptor.create(OPEN_BRACE346)
 15637  
             ;
 15638  15
             adaptor.addChild(root_0, OPEN_BRACE346_tree);
 15639  
 
 15640  
 
 15641  15
             CLOSE_BRACE347=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_nil3846); 
 15642  15
             CLOSE_BRACE347_tree = 
 15643  15
             (Object)adaptor.create(CLOSE_BRACE347)
 15644  15
             ;
 15645  15
             adaptor.addChild(root_0, CLOSE_BRACE347_tree);
 15646  
 
 15647  
 
 15648  
             }
 15649  826
 
 15650  15
             retval.stop = input.LT(-1);
 15651  826
 
 15652  
 
 15653  15
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15654  15
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15655  
 
 15656  
         }
 15657  0
         catch (RecognitionException re) {
 15658  826
             reportError(re);
 15659  826
             recover(input,re);
 15660  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15661  
 
 15662  826
         }
 15663  
 
 15664  826
         finally {
 15665  
                 // do for sure before leaving
 15666  15
         }
 15667  15
         return retval;
 15668  
     }
 15669  
     // $ANTLR end "nil"
 15670  
 
 15671  
 
 15672  826
     public static class expression_return extends ParserRuleReturnScope {
 15673  
         Object tree;
 15674  826
         public Object getTree() { return tree; }
 15675  826
     };
 15676  826
 
 15677  
 
 15678  826
     // $ANTLR start "expression"
 15679  
     // com\\googlecode\\sparkleg\\Sparql.g:474:1: expression : conditionalOrExpression ;
 15680  826
     public final SparqlParser.expression_return expression() throws RecognitionException {
 15681  826
         SparqlParser.expression_return retval = new SparqlParser.expression_return();
 15682  826
         retval.start = input.LT(1);
 15683  
 
 15684  826
 
 15685  826
         Object root_0 = null;
 15686  
 
 15687  1652
         SparqlParser.conditionalOrExpression_return conditionalOrExpression348 =null;
 15688  826
 
 15689  
 
 15690  
 
 15691  
         try {
 15692  
             // com\\googlecode\\sparkleg\\Sparql.g:475:5: ( conditionalOrExpression )
 15693  
             // com\\googlecode\\sparkleg\\Sparql.g:475:7: conditionalOrExpression
 15694  
             {
 15695  826
             root_0 = (Object)adaptor.nil();
 15696  
 
 15697  
 
 15698  826
             pushFollow(FOLLOW_conditionalOrExpression_in_expression3863);
 15699  826
             conditionalOrExpression348=conditionalOrExpression();
 15700  826
 
 15701  1652
             state._fsp--;
 15702  
 
 15703  826
             adaptor.addChild(root_0, conditionalOrExpression348.getTree());
 15704  
 
 15705  
             }
 15706  826
 
 15707  826
             retval.stop = input.LT(-1);
 15708  826
 
 15709  
 
 15710  826
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15711  826
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15712  
 
 15713  
         }
 15714  0
         catch (RecognitionException re) {
 15715  826
             reportError(re);
 15716  826
             recover(input,re);
 15717  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15718  
 
 15719  826
         }
 15720  
 
 15721  826
         finally {
 15722  826
                 // do for sure before leaving
 15723  826
         }
 15724  1652
         return retval;
 15725  
     }
 15726  
     // $ANTLR end "expression"
 15727  826
 
 15728  826
 
 15729  826
     public static class conditionalOrExpression_return extends ParserRuleReturnScope {
 15730  
         Object tree;
 15731  826
         public Object getTree() { return tree; }
 15732  
     };
 15733  
 
 15734  
 
 15735  
     // $ANTLR start "conditionalOrExpression"
 15736  
     // com\\googlecode\\sparkleg\\Sparql.g:478:1: conditionalOrExpression : (c1= conditionalAndExpression -> $c1) ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )* ;
 15737  826
     public final SparqlParser.conditionalOrExpression_return conditionalOrExpression() throws RecognitionException {
 15738  1652
         SparqlParser.conditionalOrExpression_return retval = new SparqlParser.conditionalOrExpression_return();
 15739  826
         retval.start = input.LT(1);
 15740  826
 
 15741  
 
 15742  1652
         Object root_0 = null;
 15743  
 
 15744  826
         Token OR349=null;
 15745  826
         SparqlParser.conditionalAndExpression_return c1 =null;
 15746  
 
 15747  826
         SparqlParser.conditionalAndExpression_return c2 =null;
 15748  
 
 15749  
 
 15750  826
         Object OR349_tree=null;
 15751  1652
         RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
 15752  1652
         RewriteRuleSubtreeStream stream_conditionalAndExpression=new RewriteRuleSubtreeStream(adaptor,"rule conditionalAndExpression");
 15753  826
         try {
 15754  
             // com\\googlecode\\sparkleg\\Sparql.g:479:5: ( (c1= conditionalAndExpression -> $c1) ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )* )
 15755  826
             // com\\googlecode\\sparkleg\\Sparql.g:479:7: (c1= conditionalAndExpression -> $c1) ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )*
 15756  
             {
 15757  
             // com\\googlecode\\sparkleg\\Sparql.g:479:7: (c1= conditionalAndExpression -> $c1)
 15758  826
             // com\\googlecode\\sparkleg\\Sparql.g:479:8: c1= conditionalAndExpression
 15759  
             {
 15760  826
             pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression3883);
 15761  826
             c1=conditionalAndExpression();
 15762  
 
 15763  1652
             state._fsp--;
 15764  
 
 15765  826
             stream_conditionalAndExpression.add(c1.getTree());
 15766  
 
 15767  
             // AST REWRITE
 15768  
             // elements: c1
 15769  
             // token labels: 
 15770  
             // rule labels: retval, c1
 15771  850
             // token list labels: 
 15772  850
             // rule list labels: 
 15773  
             // wildcard labels: 
 15774  826
             retval.tree = root_0;
 15775  850
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15776  826
             RewriteRuleSubtreeStream stream_c1=new RewriteRuleSubtreeStream(adaptor,"rule c1",c1!=null?c1.tree:null);
 15777  
 
 15778  826
             root_0 = (Object)adaptor.nil();
 15779  
             // 479:36: -> $c1
 15780  
             {
 15781  1676
                 adaptor.addChild(root_0, stream_c1.nextTree());
 15782  
 
 15783  
             }
 15784  
 
 15785  24
 
 15786  850
             retval.tree = root_0;
 15787  
 
 15788  
             }
 15789  24
 
 15790  24
 
 15791  
             // com\\googlecode\\sparkleg\\Sparql.g:479:44: ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )*
 15792  24
             loop117:
 15793  
             do {
 15794  874
                 int alt117=2;
 15795  850
                 switch ( input.LA(1) ) {
 15796  
                 case OR:
 15797  
                     {
 15798  24
                     alt117=1;
 15799  
                     }
 15800  
                     break;
 15801  
 
 15802  
                 }
 15803  24
 
 15804  874
                 switch (alt117) {
 15805  24
                     case 1 :
 15806  
                         // com\\googlecode\\sparkleg\\Sparql.g:479:45: OR c2= conditionalAndExpression
 15807  24
                         {
 15808  24
                         OR349=(Token)match(input,OR,FOLLOW_OR_in_conditionalOrExpression3892);  
 15809  24
                         stream_OR.add(OR349);
 15810  
 
 15811  
 
 15812  48
                         pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression3896);
 15813  48
                         c2=conditionalAndExpression();
 15814  
 
 15815  24
                         state._fsp--;
 15816  
 
 15817  48
                         stream_conditionalAndExpression.add(c2.getTree());
 15818  
 
 15819  24
                         // AST REWRITE
 15820  
                         // elements: c2, OR, conditionalOrExpression
 15821  24
                         // token labels: 
 15822  
                         // rule labels: retval, c2
 15823  
                         // token list labels: 
 15824  
                         // rule list labels: 
 15825  
                         // wildcard labels: 
 15826  24
                         retval.tree = root_0;
 15827  48
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15828  24
                         RewriteRuleSubtreeStream stream_c2=new RewriteRuleSubtreeStream(adaptor,"rule c2",c2!=null?c2.tree:null);
 15829  
 
 15830  48
                         root_0 = (Object)adaptor.nil();
 15831  
                         // 479:76: -> ^( OR $conditionalOrExpression $c2)
 15832  
                         {
 15833  826
                             // com\\googlecode\\sparkleg\\Sparql.g:479:79: ^( OR $conditionalOrExpression $c2)
 15834  
                             {
 15835  48
                             Object root_1 = (Object)adaptor.nil();
 15836  24
                             root_1 = (Object)adaptor.becomeRoot(
 15837  
                             stream_OR.nextNode()
 15838  
                             , root_1);
 15839  
 
 15840  850
                             adaptor.addChild(root_1, stream_retval.nextTree());
 15841  
 
 15842  24
                             adaptor.addChild(root_1, stream_c2.nextTree());
 15843  826
 
 15844  850
                             adaptor.addChild(root_0, root_1);
 15845  
                             }
 15846  
 
 15847  
                         }
 15848  
 
 15849  
 
 15850  24
                         retval.tree = root_0;
 15851  
 
 15852  
                         }
 15853  24
                         break;
 15854  
 
 15855  
                     default :
 15856  1652
                         break loop117;
 15857  826
                 }
 15858  24
             } while (true);
 15859  
 
 15860  
 
 15861  
             }
 15862  850
 
 15863  826
             retval.stop = input.LT(-1);
 15864  850
 
 15865  
 
 15866  826
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15867  826
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15868  
 
 15869  
         }
 15870  0
         catch (RecognitionException re) {
 15871  850
             reportError(re);
 15872  850
             recover(input,re);
 15873  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15874  
 
 15875  850
         }
 15876  
 
 15877  850
         finally {
 15878  850
                 // do for sure before leaving
 15879  826
         }
 15880  1676
         return retval;
 15881  
     }
 15882  
     // $ANTLR end "conditionalOrExpression"
 15883  850
 
 15884  850
 
 15885  850
     public static class conditionalAndExpression_return extends ParserRuleReturnScope {
 15886  
         Object tree;
 15887  850
         public Object getTree() { return tree; }
 15888  
     };
 15889  
 
 15890  
 
 15891  
     // $ANTLR start "conditionalAndExpression"
 15892  
     // com\\googlecode\\sparkleg\\Sparql.g:482:1: conditionalAndExpression : (v1= valueLogical -> $v1) ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )* ;
 15893  850
     public final SparqlParser.conditionalAndExpression_return conditionalAndExpression() throws RecognitionException {
 15894  1700
         SparqlParser.conditionalAndExpression_return retval = new SparqlParser.conditionalAndExpression_return();
 15895  850
         retval.start = input.LT(1);
 15896  850
 
 15897  
 
 15898  1700
         Object root_0 = null;
 15899  
 
 15900  850
         Token AND350=null;
 15901  850
         SparqlParser.valueLogical_return v1 =null;
 15902  
 
 15903  850
         SparqlParser.valueLogical_return v2 =null;
 15904  
 
 15905  
 
 15906  850
         Object AND350_tree=null;
 15907  1700
         RewriteRuleTokenStream stream_AND=new RewriteRuleTokenStream(adaptor,"token AND");
 15908  1700
         RewriteRuleSubtreeStream stream_valueLogical=new RewriteRuleSubtreeStream(adaptor,"rule valueLogical");
 15909  850
         try {
 15910  
             // com\\googlecode\\sparkleg\\Sparql.g:483:5: ( (v1= valueLogical -> $v1) ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )* )
 15911  850
             // com\\googlecode\\sparkleg\\Sparql.g:483:7: (v1= valueLogical -> $v1) ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )*
 15912  
             {
 15913  
             // com\\googlecode\\sparkleg\\Sparql.g:483:7: (v1= valueLogical -> $v1)
 15914  850
             // com\\googlecode\\sparkleg\\Sparql.g:483:8: v1= valueLogical
 15915  
             {
 15916  850
             pushFollow(FOLLOW_valueLogical_in_conditionalAndExpression3930);
 15917  850
             v1=valueLogical();
 15918  
 
 15919  1700
             state._fsp--;
 15920  
 
 15921  850
             stream_valueLogical.add(v1.getTree());
 15922  
 
 15923  
             // AST REWRITE
 15924  
             // elements: v1
 15925  
             // token labels: 
 15926  
             // rule labels: v1, retval
 15927  874
             // token list labels: 
 15928  874
             // rule list labels: 
 15929  
             // wildcard labels: 
 15930  850
             retval.tree = root_0;
 15931  874
             RewriteRuleSubtreeStream stream_v1=new RewriteRuleSubtreeStream(adaptor,"rule v1",v1!=null?v1.tree:null);
 15932  850
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15933  
 
 15934  850
             root_0 = (Object)adaptor.nil();
 15935  
             // 483:24: -> $v1
 15936  
             {
 15937  1724
                 adaptor.addChild(root_0, stream_v1.nextTree());
 15938  
 
 15939  
             }
 15940  
 
 15941  24
 
 15942  874
             retval.tree = root_0;
 15943  
 
 15944  
             }
 15945  24
 
 15946  24
 
 15947  
             // com\\googlecode\\sparkleg\\Sparql.g:483:32: ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )*
 15948  24
             loop118:
 15949  
             do {
 15950  898
                 int alt118=2;
 15951  874
                 switch ( input.LA(1) ) {
 15952  
                 case AND:
 15953  
                     {
 15954  24
                     alt118=1;
 15955  
                     }
 15956  
                     break;
 15957  
 
 15958  
                 }
 15959  24
 
 15960  898
                 switch (alt118) {
 15961  24
                     case 1 :
 15962  
                         // com\\googlecode\\sparkleg\\Sparql.g:483:33: AND v2= valueLogical
 15963  24
                         {
 15964  24
                         AND350=(Token)match(input,AND,FOLLOW_AND_in_conditionalAndExpression3939);  
 15965  24
                         stream_AND.add(AND350);
 15966  
 
 15967  
 
 15968  48
                         pushFollow(FOLLOW_valueLogical_in_conditionalAndExpression3943);
 15969  48
                         v2=valueLogical();
 15970  
 
 15971  24
                         state._fsp--;
 15972  
 
 15973  48
                         stream_valueLogical.add(v2.getTree());
 15974  
 
 15975  24
                         // AST REWRITE
 15976  
                         // elements: AND, v2, conditionalAndExpression
 15977  24
                         // token labels: 
 15978  
                         // rule labels: retval, v2
 15979  
                         // token list labels: 
 15980  
                         // rule list labels: 
 15981  
                         // wildcard labels: 
 15982  24
                         retval.tree = root_0;
 15983  48
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15984  24
                         RewriteRuleSubtreeStream stream_v2=new RewriteRuleSubtreeStream(adaptor,"rule v2",v2!=null?v2.tree:null);
 15985  
 
 15986  48
                         root_0 = (Object)adaptor.nil();
 15987  
                         // 483:53: -> ^( AND $conditionalAndExpression $v2)
 15988  
                         {
 15989  850
                             // com\\googlecode\\sparkleg\\Sparql.g:483:56: ^( AND $conditionalAndExpression $v2)
 15990  
                             {
 15991  48
                             Object root_1 = (Object)adaptor.nil();
 15992  24
                             root_1 = (Object)adaptor.becomeRoot(
 15993  
                             stream_AND.nextNode()
 15994  
                             , root_1);
 15995  
 
 15996  874
                             adaptor.addChild(root_1, stream_retval.nextTree());
 15997  
 
 15998  24
                             adaptor.addChild(root_1, stream_v2.nextTree());
 15999  850
 
 16000  874
                             adaptor.addChild(root_0, root_1);
 16001  
                             }
 16002  
 
 16003  
                         }
 16004  
 
 16005  
 
 16006  24
                         retval.tree = root_0;
 16007  
 
 16008  
                         }
 16009  24
                         break;
 16010  
 
 16011  
                     default :
 16012  1700
                         break loop118;
 16013  850
                 }
 16014  24
             } while (true);
 16015  
 
 16016  
 
 16017  
             }
 16018  874
 
 16019  850
             retval.stop = input.LT(-1);
 16020  874
 
 16021  
 
 16022  850
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16023  850
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16024  
 
 16025  
         }
 16026  0
         catch (RecognitionException re) {
 16027  874
             reportError(re);
 16028  874
             recover(input,re);
 16029  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16030  
 
 16031  874
         }
 16032  
 
 16033  874
         finally {
 16034  
                 // do for sure before leaving
 16035  850
         }
 16036  850
         return retval;
 16037  
     }
 16038  
     // $ANTLR end "conditionalAndExpression"
 16039  
 
 16040  
 
 16041  874
     public static class valueLogical_return extends ParserRuleReturnScope {
 16042  
         Object tree;
 16043  874
         public Object getTree() { return tree; }
 16044  874
     };
 16045  874
 
 16046  
 
 16047  874
     // $ANTLR start "valueLogical"
 16048  
     // com\\googlecode\\sparkleg\\Sparql.g:486:1: valueLogical : relationalExpression ;
 16049  874
     public final SparqlParser.valueLogical_return valueLogical() throws RecognitionException {
 16050  874
         SparqlParser.valueLogical_return retval = new SparqlParser.valueLogical_return();
 16051  874
         retval.start = input.LT(1);
 16052  
 
 16053  874
 
 16054  874
         Object root_0 = null;
 16055  
 
 16056  1748
         SparqlParser.relationalExpression_return relationalExpression351 =null;
 16057  874
 
 16058  
 
 16059  
 
 16060  
         try {
 16061  
             // com\\googlecode\\sparkleg\\Sparql.g:487:5: ( relationalExpression )
 16062  
             // com\\googlecode\\sparkleg\\Sparql.g:487:7: relationalExpression
 16063  
             {
 16064  874
             root_0 = (Object)adaptor.nil();
 16065  
 
 16066  
 
 16067  874
             pushFollow(FOLLOW_relationalExpression_in_valueLogical3974);
 16068  874
             relationalExpression351=relationalExpression();
 16069  874
 
 16070  1748
             state._fsp--;
 16071  
 
 16072  874
             adaptor.addChild(root_0, relationalExpression351.getTree());
 16073  
 
 16074  
             }
 16075  874
 
 16076  874
             retval.stop = input.LT(-1);
 16077  874
 
 16078  
 
 16079  874
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16080  874
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16081  
 
 16082  
         }
 16083  0
         catch (RecognitionException re) {
 16084  874
             reportError(re);
 16085  874
             recover(input,re);
 16086  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16087  
 
 16088  874
         }
 16089  
 
 16090  874
         finally {
 16091  874
                 // do for sure before leaving
 16092  1748
         }
 16093  1748
         return retval;
 16094  874
     }
 16095  874
     // $ANTLR end "valueLogical"
 16096  874
 
 16097  874
 
 16098  874
     public static class relationalExpression_return extends ParserRuleReturnScope {
 16099  874
         Object tree;
 16100  874
         public Object getTree() { return tree; }
 16101  874
     };
 16102  
 
 16103  874
 
 16104  
     // $ANTLR start "relationalExpression"
 16105  874
     // com\\googlecode\\sparkleg\\Sparql.g:490:1: relationalExpression : (n1= numericExpression -> $n1) ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )? ;
 16106  
     public final SparqlParser.relationalExpression_return relationalExpression() throws RecognitionException {
 16107  1748
         SparqlParser.relationalExpression_return retval = new SparqlParser.relationalExpression_return();
 16108  874
         retval.start = input.LT(1);
 16109  874
 
 16110  
 
 16111  1748
         Object root_0 = null;
 16112  
 
 16113  1748
         Token EQUAL352=null;
 16114  874
         Token NOT_EQUAL353=null;
 16115  1748
         Token LESS354=null;
 16116  874
         Token GREATER355=null;
 16117  874
         Token LESS_EQUAL356=null;
 16118  1748
         Token GREATER_EQUAL357=null;
 16119  1748
         Token IN358=null;
 16120  1748
         Token NOT359=null;
 16121  1748
         Token IN360=null;
 16122  1748
         SparqlParser.numericExpression_return n1 =null;
 16123  874
 
 16124  1748
         SparqlParser.numericExpression_return n2 =null;
 16125  874
 
 16126  1748
         SparqlParser.numericExpression_return n3 =null;
 16127  874
 
 16128  1748
         SparqlParser.numericExpression_return n4 =null;
 16129  874
 
 16130  1748
         SparqlParser.numericExpression_return n5 =null;
 16131  874
 
 16132  1748
         SparqlParser.numericExpression_return n6 =null;
 16133  874
 
 16134  1748
         SparqlParser.numericExpression_return n7 =null;
 16135  874
 
 16136  1748
         SparqlParser.expressionList_return l2 =null;
 16137  
 
 16138  874
         SparqlParser.expressionList_return l3 =null;
 16139  
 
 16140  
 
 16141  874
         Object EQUAL352_tree=null;
 16142  874
         Object NOT_EQUAL353_tree=null;
 16143  874
         Object LESS354_tree=null;
 16144  1748
         Object GREATER355_tree=null;
 16145  1748
         Object LESS_EQUAL356_tree=null;
 16146  874
         Object GREATER_EQUAL357_tree=null;
 16147  1748
         Object IN358_tree=null;
 16148  874
         Object NOT359_tree=null;
 16149  1748
         Object IN360_tree=null;
 16150  874
         RewriteRuleTokenStream stream_GREATER=new RewriteRuleTokenStream(adaptor,"token GREATER");
 16151  874
         RewriteRuleTokenStream stream_LESS_EQUAL=new RewriteRuleTokenStream(adaptor,"token LESS_EQUAL");
 16152  874
         RewriteRuleTokenStream stream_IN=new RewriteRuleTokenStream(adaptor,"token IN");
 16153  874
         RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
 16154  874
         RewriteRuleTokenStream stream_NOT_EQUAL=new RewriteRuleTokenStream(adaptor,"token NOT_EQUAL");
 16155  874
         RewriteRuleTokenStream stream_GREATER_EQUAL=new RewriteRuleTokenStream(adaptor,"token GREATER_EQUAL");
 16156  874
         RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
 16157  874
         RewriteRuleTokenStream stream_LESS=new RewriteRuleTokenStream(adaptor,"token LESS");
 16158  1748
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 16159  1748
         RewriteRuleSubtreeStream stream_numericExpression=new RewriteRuleSubtreeStream(adaptor,"rule numericExpression");
 16160  874
         try {
 16161  
             // com\\googlecode\\sparkleg\\Sparql.g:491:5: ( (n1= numericExpression -> $n1) ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )? )
 16162  874
             // com\\googlecode\\sparkleg\\Sparql.g:491:7: (n1= numericExpression -> $n1) ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )?
 16163  
             {
 16164  
             // com\\googlecode\\sparkleg\\Sparql.g:491:7: (n1= numericExpression -> $n1)
 16165  874
             // com\\googlecode\\sparkleg\\Sparql.g:491:8: n1= numericExpression
 16166  
             {
 16167  874
             pushFollow(FOLLOW_numericExpression_in_relationalExpression3994);
 16168  874
             n1=numericExpression();
 16169  
 
 16170  1748
             state._fsp--;
 16171  
 
 16172  874
             stream_numericExpression.add(n1.getTree());
 16173  
 
 16174  
             // AST REWRITE
 16175  
             // elements: n1
 16176  874
             // token labels: 
 16177  874
             // rule labels: n1, retval
 16178  
             // token list labels: 
 16179  
             // rule list labels: 
 16180  138
             // wildcard labels: 
 16181  874
             retval.tree = root_0;
 16182  1012
             RewriteRuleSubtreeStream stream_n1=new RewriteRuleSubtreeStream(adaptor,"rule n1",n1!=null?n1.tree:null);
 16183  874
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16184  
 
 16185  902
             root_0 = (Object)adaptor.nil();
 16186  
             // 491:29: -> $n1
 16187  28
             {
 16188  874
                 adaptor.addChild(root_0, stream_n1.nextTree());
 16189  
 
 16190  18
             }
 16191  
 
 16192  18
 
 16193  874
             retval.tree = root_0;
 16194  
 
 16195  18
             }
 16196  
 
 16197  18
 
 16198  
             // com\\googlecode\\sparkleg\\Sparql.g:491:37: ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )?
 16199  874
             int alt119=9;
 16200  876
             switch ( input.LA(1) ) {
 16201  
                 case EQUAL:
 16202  2
                     {
 16203  138
                     alt119=1;
 16204  
                     }
 16205  141
                     break;
 16206  
                 case NOT_EQUAL:
 16207  3
                     {
 16208  28
                     alt119=2;
 16209  
                     }
 16210  30
                     break;
 16211  
                 case LESS:
 16212  2
                     {
 16213  18
                     alt119=3;
 16214  
                     }
 16215  20
                     break;
 16216  
                 case GREATER:
 16217  
                     {
 16218  18
                     alt119=4;
 16219  
                     }
 16220  892
                     break;
 16221  
                 case LESS_EQUAL:
 16222  
                     {
 16223  2
                     alt119=5;
 16224  
                     }
 16225  2
                     break;
 16226  
                 case GREATER_EQUAL:
 16227  138
                     {
 16228  141
                     alt119=6;
 16229  
                     }
 16230  3
                     break;
 16231  138
                 case IN:
 16232  138
                     {
 16233  2
                     alt119=7;
 16234  138
                     }
 16235  2
                     break;
 16236  138
                 case NOT:
 16237  
                     {
 16238  2
                     alt119=8;
 16239  
                     }
 16240  
                     break;
 16241  
             }
 16242  
 
 16243  874
             switch (alt119) {
 16244  
                 case 1 :
 16245  138
                     // com\\googlecode\\sparkleg\\Sparql.g:491:38: ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) )
 16246  138
                     {
 16247  138
                     // com\\googlecode\\sparkleg\\Sparql.g:491:38: ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) )
 16248  
                     // com\\googlecode\\sparkleg\\Sparql.g:491:39: EQUAL n2= numericExpression
 16249  138
                     {
 16250  138
                     EQUAL352=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_relationalExpression4004);  
 16251  138
                     stream_EQUAL.add(EQUAL352);
 16252  
 
 16253  
 
 16254  276
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4008);
 16255  276
                     n2=numericExpression();
 16256  
 
 16257  138
                     state._fsp--;
 16258  
 
 16259  276
                     stream_numericExpression.add(n2.getTree());
 16260  
 
 16261  138
                     // AST REWRITE
 16262  
                     // elements: relationalExpression, EQUAL, n2
 16263  138
                     // token labels: 
 16264  
                     // rule labels: retval, n2
 16265  
                     // token list labels: 
 16266  
                     // rule list labels: 
 16267  
                     // wildcard labels: 
 16268  138
                     retval.tree = root_0;
 16269  276
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16270  138
                     RewriteRuleSubtreeStream stream_n2=new RewriteRuleSubtreeStream(adaptor,"rule n2",n2!=null?n2.tree:null);
 16271  
 
 16272  138
                     root_0 = (Object)adaptor.nil();
 16273  
                     // 491:66: -> ^( EQUAL $relationalExpression $n2)
 16274  
                     {
 16275  138
                         // com\\googlecode\\sparkleg\\Sparql.g:491:69: ^( EQUAL $relationalExpression $n2)
 16276  
                         {
 16277  138
                         Object root_1 = (Object)adaptor.nil();
 16278  138
                         root_1 = (Object)adaptor.becomeRoot(
 16279  
                         stream_EQUAL.nextNode()
 16280  
                         , root_1);
 16281  
 
 16282  166
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16283  28
 
 16284  138
                         adaptor.addChild(root_1, stream_n2.nextTree());
 16285  
 
 16286  166
                         adaptor.addChild(root_0, root_1);
 16287  28
                         }
 16288  
 
 16289  28
                     }
 16290  
 
 16291  28
 
 16292  138
                     retval.tree = root_0;
 16293  
 
 16294  
                     }
 16295  
 
 16296  
 
 16297  
                     }
 16298  138
                     break;
 16299  
                 case 2 :
 16300  28
                     // com\\googlecode\\sparkleg\\Sparql.g:492:39: ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) )
 16301  28
                     {
 16302  28
                     // com\\googlecode\\sparkleg\\Sparql.g:492:39: ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) )
 16303  
                     // com\\googlecode\\sparkleg\\Sparql.g:492:40: NOT_EQUAL n3= numericExpression
 16304  28
                     {
 16305  28
                     NOT_EQUAL353=(Token)match(input,NOT_EQUAL,FOLLOW_NOT_EQUAL_in_relationalExpression4065);  
 16306  28
                     stream_NOT_EQUAL.add(NOT_EQUAL353);
 16307  
 
 16308  
 
 16309  56
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4069);
 16310  56
                     n3=numericExpression();
 16311  
 
 16312  28
                     state._fsp--;
 16313  
 
 16314  56
                     stream_numericExpression.add(n3.getTree());
 16315  
 
 16316  28
                     // AST REWRITE
 16317  
                     // elements: relationalExpression, n3, NOT_EQUAL
 16318  28
                     // token labels: 
 16319  
                     // rule labels: retval, n3
 16320  
                     // token list labels: 
 16321  
                     // rule list labels: 
 16322  
                     // wildcard labels: 
 16323  28
                     retval.tree = root_0;
 16324  56
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16325  28
                     RewriteRuleSubtreeStream stream_n3=new RewriteRuleSubtreeStream(adaptor,"rule n3",n3!=null?n3.tree:null);
 16326  
 
 16327  28
                     root_0 = (Object)adaptor.nil();
 16328  
                     // 492:71: -> ^( NOT_EQUAL $relationalExpression $n3)
 16329  
                     {
 16330  28
                         // com\\googlecode\\sparkleg\\Sparql.g:492:74: ^( NOT_EQUAL $relationalExpression $n3)
 16331  
                         {
 16332  28
                         Object root_1 = (Object)adaptor.nil();
 16333  28
                         root_1 = (Object)adaptor.becomeRoot(
 16334  
                         stream_NOT_EQUAL.nextNode()
 16335  
                         , root_1);
 16336  
 
 16337  46
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16338  18
 
 16339  28
                         adaptor.addChild(root_1, stream_n3.nextTree());
 16340  
 
 16341  46
                         adaptor.addChild(root_0, root_1);
 16342  18
                         }
 16343  
 
 16344  18
                     }
 16345  
 
 16346  18
 
 16347  28
                     retval.tree = root_0;
 16348  
 
 16349  
                     }
 16350  
 
 16351  
 
 16352  
                     }
 16353  28
                     break;
 16354  
                 case 3 :
 16355  18
                     // com\\googlecode\\sparkleg\\Sparql.g:493:39: ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) )
 16356  18
                     {
 16357  18
                     // com\\googlecode\\sparkleg\\Sparql.g:493:39: ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) )
 16358  
                     // com\\googlecode\\sparkleg\\Sparql.g:493:40: LESS n4= numericExpression
 16359  18
                     {
 16360  18
                     LESS354=(Token)match(input,LESS,FOLLOW_LESS_in_relationalExpression4124);  
 16361  18
                     stream_LESS.add(LESS354);
 16362  
 
 16363  
 
 16364  36
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4128);
 16365  36
                     n4=numericExpression();
 16366  
 
 16367  18
                     state._fsp--;
 16368  
 
 16369  36
                     stream_numericExpression.add(n4.getTree());
 16370  
 
 16371  18
                     // AST REWRITE
 16372  
                     // elements: n4, LESS, relationalExpression
 16373  18
                     // token labels: 
 16374  
                     // rule labels: retval, n4
 16375  
                     // token list labels: 
 16376  
                     // rule list labels: 
 16377  
                     // wildcard labels: 
 16378  18
                     retval.tree = root_0;
 16379  36
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16380  18
                     RewriteRuleSubtreeStream stream_n4=new RewriteRuleSubtreeStream(adaptor,"rule n4",n4!=null?n4.tree:null);
 16381  
 
 16382  18
                     root_0 = (Object)adaptor.nil();
 16383  
                     // 493:66: -> ^( LESS $relationalExpression $n4)
 16384  
                     {
 16385  18
                         // com\\googlecode\\sparkleg\\Sparql.g:493:69: ^( LESS $relationalExpression $n4)
 16386  
                         {
 16387  18
                         Object root_1 = (Object)adaptor.nil();
 16388  18
                         root_1 = (Object)adaptor.becomeRoot(
 16389  
                         stream_LESS.nextNode()
 16390  
                         , root_1);
 16391  
 
 16392  36
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16393  18
 
 16394  18
                         adaptor.addChild(root_1, stream_n4.nextTree());
 16395  
 
 16396  36
                         adaptor.addChild(root_0, root_1);
 16397  18
                         }
 16398  
 
 16399  18
                     }
 16400  
 
 16401  18
 
 16402  18
                     retval.tree = root_0;
 16403  
 
 16404  
                     }
 16405  
 
 16406  
 
 16407  
                     }
 16408  18
                     break;
 16409  
                 case 4 :
 16410  18
                     // com\\googlecode\\sparkleg\\Sparql.g:494:39: ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) )
 16411  18
                     {
 16412  18
                     // com\\googlecode\\sparkleg\\Sparql.g:494:39: ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) )
 16413  
                     // com\\googlecode\\sparkleg\\Sparql.g:494:40: GREATER n5= numericExpression
 16414  18
                     {
 16415  18
                     GREATER355=(Token)match(input,GREATER,FOLLOW_GREATER_in_relationalExpression4183);  
 16416  18
                     stream_GREATER.add(GREATER355);
 16417  
 
 16418  
 
 16419  36
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4187);
 16420  36
                     n5=numericExpression();
 16421  
 
 16422  18
                     state._fsp--;
 16423  
 
 16424  36
                     stream_numericExpression.add(n5.getTree());
 16425  
 
 16426  18
                     // AST REWRITE
 16427  
                     // elements: relationalExpression, GREATER, n5
 16428  18
                     // token labels: 
 16429  
                     // rule labels: retval, n5
 16430  
                     // token list labels: 
 16431  
                     // rule list labels: 
 16432  
                     // wildcard labels: 
 16433  18
                     retval.tree = root_0;
 16434  36
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16435  18
                     RewriteRuleSubtreeStream stream_n5=new RewriteRuleSubtreeStream(adaptor,"rule n5",n5!=null?n5.tree:null);
 16436  
 
 16437  18
                     root_0 = (Object)adaptor.nil();
 16438  
                     // 494:69: -> ^( GREATER $relationalExpression $n5)
 16439  
                     {
 16440  18
                         // com\\googlecode\\sparkleg\\Sparql.g:494:72: ^( GREATER $relationalExpression $n5)
 16441  
                         {
 16442  18
                         Object root_1 = (Object)adaptor.nil();
 16443  18
                         root_1 = (Object)adaptor.becomeRoot(
 16444  
                         stream_GREATER.nextNode()
 16445  
                         , root_1);
 16446  
 
 16447  20
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16448  2
 
 16449  18
                         adaptor.addChild(root_1, stream_n5.nextTree());
 16450  
 
 16451  20
                         adaptor.addChild(root_0, root_1);
 16452  2
                         }
 16453  
 
 16454  2
                     }
 16455  
 
 16456  2
 
 16457  18
                     retval.tree = root_0;
 16458  
 
 16459  
                     }
 16460  
 
 16461  
 
 16462  
                     }
 16463  18
                     break;
 16464  
                 case 5 :
 16465  2
                     // com\\googlecode\\sparkleg\\Sparql.g:495:39: ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) )
 16466  2
                     {
 16467  2
                     // com\\googlecode\\sparkleg\\Sparql.g:495:39: ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) )
 16468  
                     // com\\googlecode\\sparkleg\\Sparql.g:495:40: LESS_EQUAL n6= numericExpression
 16469  2
                     {
 16470  2
                     LESS_EQUAL356=(Token)match(input,LESS_EQUAL,FOLLOW_LESS_EQUAL_in_relationalExpression4241);  
 16471  2
                     stream_LESS_EQUAL.add(LESS_EQUAL356);
 16472  
 
 16473  
 
 16474  4
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4245);
 16475  4
                     n6=numericExpression();
 16476  
 
 16477  2
                     state._fsp--;
 16478  
 
 16479  4
                     stream_numericExpression.add(n6.getTree());
 16480  
 
 16481  2
                     // AST REWRITE
 16482  
                     // elements: n6, relationalExpression, LESS_EQUAL
 16483  2
                     // token labels: 
 16484  
                     // rule labels: retval, n6
 16485  
                     // token list labels: 
 16486  
                     // rule list labels: 
 16487  
                     // wildcard labels: 
 16488  2
                     retval.tree = root_0;
 16489  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16490  2
                     RewriteRuleSubtreeStream stream_n6=new RewriteRuleSubtreeStream(adaptor,"rule n6",n6!=null?n6.tree:null);
 16491  
 
 16492  2
                     root_0 = (Object)adaptor.nil();
 16493  
                     // 495:72: -> ^( LESS_EQUAL $relationalExpression $n6)
 16494  
                     {
 16495  2
                         // com\\googlecode\\sparkleg\\Sparql.g:495:75: ^( LESS_EQUAL $relationalExpression $n6)
 16496  
                         {
 16497  2
                         Object root_1 = (Object)adaptor.nil();
 16498  2
                         root_1 = (Object)adaptor.becomeRoot(
 16499  
                         stream_LESS_EQUAL.nextNode()
 16500  
                         , root_1);
 16501  
 
 16502  5
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16503  3
 
 16504  2
                         adaptor.addChild(root_1, stream_n6.nextTree());
 16505  
 
 16506  5
                         adaptor.addChild(root_0, root_1);
 16507  3
                         }
 16508  
 
 16509  3
                     }
 16510  
 
 16511  3
 
 16512  2
                     retval.tree = root_0;
 16513  
 
 16514  
                     }
 16515  
 
 16516  
 
 16517  
                     }
 16518  2
                     break;
 16519  
                 case 6 :
 16520  3
                     // com\\googlecode\\sparkleg\\Sparql.g:496:39: ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) )
 16521  3
                     {
 16522  3
                     // com\\googlecode\\sparkleg\\Sparql.g:496:39: ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) )
 16523  
                     // com\\googlecode\\sparkleg\\Sparql.g:496:40: GREATER_EQUAL n7= numericExpression
 16524  3
                     {
 16525  3
                     GREATER_EQUAL357=(Token)match(input,GREATER_EQUAL,FOLLOW_GREATER_EQUAL_in_relationalExpression4299);  
 16526  3
                     stream_GREATER_EQUAL.add(GREATER_EQUAL357);
 16527  
 
 16528  
 
 16529  6
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4303);
 16530  6
                     n7=numericExpression();
 16531  
 
 16532  3
                     state._fsp--;
 16533  
 
 16534  6
                     stream_numericExpression.add(n7.getTree());
 16535  
 
 16536  3
                     // AST REWRITE
 16537  
                     // elements: relationalExpression, n7, GREATER_EQUAL
 16538  3
                     // token labels: 
 16539  
                     // rule labels: retval, n7
 16540  
                     // token list labels: 
 16541  
                     // rule list labels: 
 16542  
                     // wildcard labels: 
 16543  3
                     retval.tree = root_0;
 16544  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16545  3
                     RewriteRuleSubtreeStream stream_n7=new RewriteRuleSubtreeStream(adaptor,"rule n7",n7!=null?n7.tree:null);
 16546  
 
 16547  3
                     root_0 = (Object)adaptor.nil();
 16548  
                     // 496:75: -> ^( GREATER_EQUAL $relationalExpression $n7)
 16549  
                     {
 16550  3
                         // com\\googlecode\\sparkleg\\Sparql.g:496:78: ^( GREATER_EQUAL $relationalExpression $n7)
 16551  
                         {
 16552  3
                         Object root_1 = (Object)adaptor.nil();
 16553  3
                         root_1 = (Object)adaptor.becomeRoot(
 16554  
                         stream_GREATER_EQUAL.nextNode()
 16555  
                         , root_1);
 16556  
 
 16557  5
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16558  2
 
 16559  3
                         adaptor.addChild(root_1, stream_n7.nextTree());
 16560  
 
 16561  5
                         adaptor.addChild(root_0, root_1);
 16562  2
                         }
 16563  
 
 16564  2
                     }
 16565  
 
 16566  2
 
 16567  3
                     retval.tree = root_0;
 16568  
 
 16569  
                     }
 16570  
 
 16571  
 
 16572  
                     }
 16573  3
                     break;
 16574  
                 case 7 :
 16575  2
                     // com\\googlecode\\sparkleg\\Sparql.g:497:39: ( IN l2= expressionList -> ^( IN $relationalExpression $l2) )
 16576  2
                     {
 16577  2
                     // com\\googlecode\\sparkleg\\Sparql.g:497:39: ( IN l2= expressionList -> ^( IN $relationalExpression $l2) )
 16578  
                     // com\\googlecode\\sparkleg\\Sparql.g:497:40: IN l2= expressionList
 16579  2
                     {
 16580  2
                     IN358=(Token)match(input,IN,FOLLOW_IN_in_relationalExpression4359);  
 16581  2
                     stream_IN.add(IN358);
 16582  
 
 16583  
 
 16584  4
                     pushFollow(FOLLOW_expressionList_in_relationalExpression4363);
 16585  4
                     l2=expressionList();
 16586  
 
 16587  2
                     state._fsp--;
 16588  
 
 16589  4
                     stream_expressionList.add(l2.getTree());
 16590  
 
 16591  2
                     // AST REWRITE
 16592  
                     // elements: relationalExpression, l2, IN
 16593  2
                     // token labels: 
 16594  
                     // rule labels: retval, l2
 16595  
                     // token list labels: 
 16596  
                     // rule list labels: 
 16597  
                     // wildcard labels: 
 16598  2
                     retval.tree = root_0;
 16599  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16600  2
                     RewriteRuleSubtreeStream stream_l2=new RewriteRuleSubtreeStream(adaptor,"rule l2",l2!=null?l2.tree:null);
 16601  
 
 16602  2
                     root_0 = (Object)adaptor.nil();
 16603  
                     // 497:61: -> ^( IN $relationalExpression $l2)
 16604  
                     {
 16605  2
                         // com\\googlecode\\sparkleg\\Sparql.g:497:64: ^( IN $relationalExpression $l2)
 16606  
                         {
 16607  2
                         Object root_1 = (Object)adaptor.nil();
 16608  2
                         root_1 = (Object)adaptor.becomeRoot(
 16609  
                         stream_IN.nextNode()
 16610  
                         , root_1);
 16611  
 
 16612  4
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16613  2
 
 16614  2
                         adaptor.addChild(root_1, stream_l2.nextTree());
 16615  
 
 16616  4
                         adaptor.addChild(root_0, root_1);
 16617  2
                         }
 16618  
 
 16619  
                     }
 16620  2
 
 16621  2
 
 16622  2
                     retval.tree = root_0;
 16623  2
 
 16624  
                     }
 16625  2
 
 16626  
 
 16627  
                     }
 16628  2
                     break;
 16629  
                 case 8 :
 16630  
                     // com\\googlecode\\sparkleg\\Sparql.g:498:39: ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) )
 16631  
                     {
 16632  
                     // com\\googlecode\\sparkleg\\Sparql.g:498:39: ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) )
 16633  
                     // com\\googlecode\\sparkleg\\Sparql.g:498:40: NOT IN l3= expressionList
 16634  2
                     {
 16635  4
                     NOT359=(Token)match(input,NOT,FOLLOW_NOT_in_relationalExpression4417);  
 16636  4
                     stream_NOT.add(NOT359);
 16637  
 
 16638  2
 
 16639  2
                     IN360=(Token)match(input,IN,FOLLOW_IN_in_relationalExpression4419);  
 16640  2
                     stream_IN.add(IN360);
 16641  
 
 16642  
 
 16643  4
                     pushFollow(FOLLOW_expressionList_in_relationalExpression4423);
 16644  4
                     l3=expressionList();
 16645  
 
 16646  2
                     state._fsp--;
 16647  
 
 16648  4
                     stream_expressionList.add(l3.getTree());
 16649  
 
 16650  
                     // AST REWRITE
 16651  
                     // elements: l3, IN, NOT, relationalExpression
 16652  2
                     // token labels: 
 16653  
                     // rule labels: retval, l3
 16654  2
                     // token list labels: 
 16655  
                     // rule list labels: 
 16656  2
                     // wildcard labels: 
 16657  2
                     retval.tree = root_0;
 16658  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16659  2
                     RewriteRuleSubtreeStream stream_l3=new RewriteRuleSubtreeStream(adaptor,"rule l3",l3!=null?l3.tree:null);
 16660  
 
 16661  2
                     root_0 = (Object)adaptor.nil();
 16662  2
                     // 498:65: -> ^( NOT IN $relationalExpression $l3)
 16663  
                     {
 16664  
                         // com\\googlecode\\sparkleg\\Sparql.g:498:68: ^( NOT IN $relationalExpression $l3)
 16665  
                         {
 16666  2
                         Object root_1 = (Object)adaptor.nil();
 16667  2
                         root_1 = (Object)adaptor.becomeRoot(
 16668  
                         stream_NOT.nextNode()
 16669  
                         , root_1);
 16670  
 
 16671  2
                         adaptor.addChild(root_1, 
 16672  
                         stream_IN.nextNode()
 16673  
                         );
 16674  
 
 16675  876
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16676  
 
 16677  2
                         adaptor.addChild(root_1, stream_l3.nextTree());
 16678  874
 
 16679  876
                         adaptor.addChild(root_0, root_1);
 16680  
                         }
 16681  
 
 16682  
                     }
 16683  
 
 16684  
 
 16685  2
                     retval.tree = root_0;
 16686  
 
 16687  
                     }
 16688  
 
 16689  
 
 16690  
                     }
 16691  874
                     break;
 16692  874
 
 16693  
             }
 16694  
 
 16695  
 
 16696  
             }
 16697  1081
 
 16698  874
             retval.stop = input.LT(-1);
 16699  1081
 
 16700  
 
 16701  874
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16702  874
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16703  
 
 16704  
         }
 16705  0
         catch (RecognitionException re) {
 16706  1081
             reportError(re);
 16707  1081
             recover(input,re);
 16708  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16709  
 
 16710  1081
         }
 16711  
 
 16712  1081
         finally {
 16713  
                 // do for sure before leaving
 16714  874
         }
 16715  874
         return retval;
 16716  
     }
 16717  
     // $ANTLR end "relationalExpression"
 16718  
 
 16719  
 
 16720  1081
     public static class numericExpression_return extends ParserRuleReturnScope {
 16721  
         Object tree;
 16722  1081
         public Object getTree() { return tree; }
 16723  1081
     };
 16724  1081
 
 16725  
 
 16726  1081
     // $ANTLR start "numericExpression"
 16727  
     // com\\googlecode\\sparkleg\\Sparql.g:501:1: numericExpression : additiveExpression ;
 16728  1081
     public final SparqlParser.numericExpression_return numericExpression() throws RecognitionException {
 16729  1081
         SparqlParser.numericExpression_return retval = new SparqlParser.numericExpression_return();
 16730  1081
         retval.start = input.LT(1);
 16731  
 
 16732  1081
 
 16733  1081
         Object root_0 = null;
 16734  
 
 16735  2162
         SparqlParser.additiveExpression_return additiveExpression361 =null;
 16736  1081
 
 16737  
 
 16738  
 
 16739  
         try {
 16740  
             // com\\googlecode\\sparkleg\\Sparql.g:502:5: ( additiveExpression )
 16741  
             // com\\googlecode\\sparkleg\\Sparql.g:502:7: additiveExpression
 16742  
             {
 16743  1081
             root_0 = (Object)adaptor.nil();
 16744  
 
 16745  
 
 16746  1081
             pushFollow(FOLLOW_additiveExpression_in_numericExpression4457);
 16747  1081
             additiveExpression361=additiveExpression();
 16748  1081
 
 16749  2162
             state._fsp--;
 16750  
 
 16751  1081
             adaptor.addChild(root_0, additiveExpression361.getTree());
 16752  
 
 16753  
             }
 16754  1081
 
 16755  1081
             retval.stop = input.LT(-1);
 16756  1081
 
 16757  
 
 16758  1081
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16759  1081
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16760  
 
 16761  
         }
 16762  0
         catch (RecognitionException re) {
 16763  1081
             reportError(re);
 16764  1081
             recover(input,re);
 16765  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16766  
 
 16767  1081
         }
 16768  
 
 16769  1081
         finally {
 16770  1081
                 // do for sure before leaving
 16771  2162
         }
 16772  1081
         return retval;
 16773  1081
     }
 16774  
     // $ANTLR end "numericExpression"
 16775  1081
 
 16776  
 
 16777  1081
     public static class additiveExpression_return extends ParserRuleReturnScope {
 16778  
         Object tree;
 16779  1081
         public Object getTree() { return tree; }
 16780  
     };
 16781  1081
 
 16782  
 
 16783  
     // $ANTLR start "additiveExpression"
 16784  1081
     // com\\googlecode\\sparkleg\\Sparql.g:505:1: additiveExpression : (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )* ;
 16785  1081
     public final SparqlParser.additiveExpression_return additiveExpression() throws RecognitionException {
 16786  2162
         SparqlParser.additiveExpression_return retval = new SparqlParser.additiveExpression_return();
 16787  2162
         retval.start = input.LT(1);
 16788  1081
 
 16789  1081
 
 16790  2162
         Object root_0 = null;
 16791  1081
 
 16792  2162
         Token ASTERISK363=null;
 16793  1081
         Token DIVIDE364=null;
 16794  1081
         SparqlParser.multiplicativeExpression_return m1 =null;
 16795  
 
 16796  1081
         SparqlParser.multiplicativeExpression_return m2 =null;
 16797  
 
 16798  1081
         SparqlParser.numericLiteralPositive_return n1 =null;
 16799  
 
 16800  2162
         SparqlParser.numericLiteralNegative_return n2 =null;
 16801  1081
 
 16802  1081
         SparqlParser.unaryExpression_return u2 =null;
 16803  1081
 
 16804  1081
         SparqlParser.additiveOperator_return additiveOperator362 =null;
 16805  1081
 
 16806  
 
 16807  1081
         Object ASTERISK363_tree=null;
 16808  1081
         Object DIVIDE364_tree=null;
 16809  1081
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 16810  1081
         RewriteRuleTokenStream stream_DIVIDE=new RewriteRuleTokenStream(adaptor,"token DIVIDE");
 16811  1081
         RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
 16812  1081
         RewriteRuleSubtreeStream stream_numericLiteralNegative=new RewriteRuleSubtreeStream(adaptor,"rule numericLiteralNegative");
 16813  1081
         RewriteRuleSubtreeStream stream_numericLiteralPositive=new RewriteRuleSubtreeStream(adaptor,"rule numericLiteralPositive");
 16814  2162
         RewriteRuleSubtreeStream stream_additiveOperator=new RewriteRuleSubtreeStream(adaptor,"rule additiveOperator");
 16815  2162
         RewriteRuleSubtreeStream stream_multiplicativeExpression=new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeExpression");
 16816  1081
         try {
 16817  
             // com\\googlecode\\sparkleg\\Sparql.g:506:5: ( (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )* )
 16818  1081
             // com\\googlecode\\sparkleg\\Sparql.g:506:7: (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )*
 16819  
             {
 16820  
             // com\\googlecode\\sparkleg\\Sparql.g:506:7: (m1= multiplicativeExpression -> $m1)
 16821  1081
             // com\\googlecode\\sparkleg\\Sparql.g:506:8: m1= multiplicativeExpression
 16822  
             {
 16823  1081
             pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4477);
 16824  1081
             m1=multiplicativeExpression();
 16825  
 
 16826  2162
             state._fsp--;
 16827  
 
 16828  1081
             stream_multiplicativeExpression.add(m1.getTree());
 16829  
 
 16830  
             // AST REWRITE
 16831  
             // elements: m1
 16832  
             // token labels: 
 16833  
             // rule labels: retval, m1
 16834  1154
             // token list labels: 
 16835  1154
             // rule list labels: 
 16836  
             // wildcard labels: 
 16837  1081
             retval.tree = root_0;
 16838  1081
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16839  1134
             RewriteRuleSubtreeStream stream_m1=new RewriteRuleSubtreeStream(adaptor,"rule m1",m1!=null?m1.tree:null);
 16840  
 
 16841  1134
             root_0 = (Object)adaptor.nil();
 16842  
             // 506:36: -> $m1
 16843  
             {
 16844  1081
                 adaptor.addChild(root_0, stream_m1.nextTree());
 16845  
 
 16846  
             }
 16847  
 
 16848  
 
 16849  1101
             retval.tree = root_0;
 16850  
 
 16851  
             }
 16852  
 
 16853  
 
 16854  
             // com\\googlecode\\sparkleg\\Sparql.g:506:44: ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )*
 16855  1154
             loop122:
 16856  
             do {
 16857  1154
                 int alt122=3;
 16858  1154
                 switch ( input.LA(1) ) {
 16859  
                 case MINUS:
 16860  
                 case PLUS:
 16861  
                     {
 16862  106
                     alt122=1;
 16863  53
                     }
 16864  53
                     break;
 16865  53
                 case DECIMAL_NEGATIVE:
 16866  
                 case DECIMAL_POSITIVE:
 16867  53
                 case DOUBLE_NEGATIVE:
 16868  
                 case DOUBLE_POSITIVE:
 16869  53
                 case INTEGER_NEGATIVE:
 16870  53
                 case INTEGER_POSITIVE:
 16871  
                     {
 16872  73
                     alt122=2;
 16873  
                     }
 16874  53
                     break;
 16875  
 
 16876  
                 }
 16877  
 
 16878  1154
                 switch (alt122) {
 16879  
                     case 1 :
 16880  
                         // com\\googlecode\\sparkleg\\Sparql.g:506:45: ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) )
 16881  
                         {
 16882  
                         // com\\googlecode\\sparkleg\\Sparql.g:506:45: ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) )
 16883  53
                         // com\\googlecode\\sparkleg\\Sparql.g:506:46: additiveOperator m2= multiplicativeExpression
 16884  53
                         {
 16885  106
                         pushFollow(FOLLOW_additiveOperator_in_additiveExpression4487);
 16886  53
                         additiveOperator362=additiveOperator();
 16887  53
 
 16888  53
                         state._fsp--;
 16889  
 
 16890  53
                         stream_additiveOperator.add(additiveOperator362.getTree());
 16891  
 
 16892  106
                         pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4491);
 16893  106
                         m2=multiplicativeExpression();
 16894  
 
 16895  106
                         state._fsp--;
 16896  
 
 16897  106
                         stream_multiplicativeExpression.add(m2.getTree());
 16898  
 
 16899  53
                         // AST REWRITE
 16900  
                         // elements: additiveExpression, additiveOperator, m2
 16901  
                         // token labels: 
 16902  
                         // rule labels: retval, m2
 16903  
                         // token list labels: 
 16904  
                         // rule list labels: 
 16905  53
                         // wildcard labels: 
 16906  53
                         retval.tree = root_0;
 16907  53
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16908  53
                         RewriteRuleSubtreeStream stream_m2=new RewriteRuleSubtreeStream(adaptor,"rule m2",m2!=null?m2.tree:null);
 16909  
 
 16910  53
                         root_0 = (Object)adaptor.nil();
 16911  53
                         // 506:91: -> ^( additiveOperator $additiveExpression $m2)
 16912  
                         {
 16913  
                             // com\\googlecode\\sparkleg\\Sparql.g:506:94: ^( additiveOperator $additiveExpression $m2)
 16914  
                             {
 16915  53
                             Object root_1 = (Object)adaptor.nil();
 16916  73
                             root_1 = (Object)adaptor.becomeRoot(stream_additiveOperator.nextNode(), root_1);
 16917  20
 
 16918  53
                             adaptor.addChild(root_1, stream_retval.nextTree());
 16919  
 
 16920  53
                             adaptor.addChild(root_1, stream_m2.nextTree());
 16921  
 
 16922  73
                             adaptor.addChild(root_0, root_1);
 16923  
                             }
 16924  20
 
 16925  
                         }
 16926  
 
 16927  
 
 16928  53
                         retval.tree = root_0;
 16929  
 
 16930  
                         }
 16931  
 
 16932  
 
 16933  
                         }
 16934  53
                         break;
 16935  
                     case 2 :
 16936  
                         // com\\googlecode\\sparkleg\\Sparql.g:507:48: (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )?
 16937  
                         {
 16938  
                         // com\\googlecode\\sparkleg\\Sparql.g:507:48: (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) )
 16939  20
                         int alt120=2;
 16940  40
                         switch ( input.LA(1) ) {
 16941  
                         case DECIMAL_POSITIVE:
 16942  
                         case DOUBLE_POSITIVE:
 16943  
                         case INTEGER_POSITIVE:
 16944  20
                             {
 16945  40
                             alt120=1;
 16946  
                             }
 16947  40
                             break;
 16948  
                         case DECIMAL_NEGATIVE:
 16949  20
                         case DOUBLE_NEGATIVE:
 16950  
                         case INTEGER_NEGATIVE:
 16951  
                             {
 16952  0
                             alt120=2;
 16953  
                             }
 16954  0
                             break;
 16955  
                         default:
 16956  0
                             NoViableAltException nvae =
 16957  
                                 new NoViableAltException("", 120, 0, input);
 16958  20
 
 16959  20
                             throw nvae;
 16960  20
 
 16961  
                         }
 16962  20
 
 16963  20
                         switch (alt120) {
 16964  
                             case 1 :
 16965  
                                 // com\\googlecode\\sparkleg\\Sparql.g:507:49: n1= numericLiteralPositive
 16966  
                                 {
 16967  40
                                 pushFollow(FOLLOW_numericLiteralPositive_in_additiveExpression4558);
 16968  40
                                 n1=numericLiteralPositive();
 16969  
 
 16970  20
                                 state._fsp--;
 16971  
 
 16972  40
                                 stream_numericLiteralPositive.add(n1.getTree());
 16973  
 
 16974  20
                                 // AST REWRITE
 16975  
                                 // elements: n1, additiveExpression
 16976  20
                                 // token labels: 
 16977  
                                 // rule labels: n1, retval
 16978  
                                 // token list labels: 
 16979  
                                 // rule list labels: 
 16980  
                                 // wildcard labels: 
 16981  20
                                 retval.tree = root_0;
 16982  40
                                 RewriteRuleSubtreeStream stream_n1=new RewriteRuleSubtreeStream(adaptor,"rule n1",n1!=null?n1.tree:null);
 16983  20
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16984  
 
 16985  40
                                 root_0 = (Object)adaptor.nil();
 16986  
                                 // 507:75: -> ^( PLUS $additiveExpression $n1)
 16987  
                                 {
 16988  
                                     // com\\googlecode\\sparkleg\\Sparql.g:507:78: ^( PLUS $additiveExpression $n1)
 16989  
                                     {
 16990  20
                                     Object root_1 = (Object)adaptor.nil();
 16991  20
                                     root_1 = (Object)adaptor.becomeRoot(
 16992  
                                     (Object)adaptor.create(PLUS, "PLUS")
 16993  
                                     , root_1);
 16994  
 
 16995  20
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 16996  
 
 16997  20
                                     adaptor.addChild(root_1, stream_n1.nextTree());
 16998  
 
 16999  20
                                     adaptor.addChild(root_0, root_1);
 17000  
                                     }
 17001  
 
 17002  
                                 }
 17003  
 
 17004  
 
 17005  20
                                 retval.tree = root_0;
 17006  
 
 17007  
                                 }
 17008  20
                                 break;
 17009  
                             case 2 :
 17010  
                                 // com\\googlecode\\sparkleg\\Sparql.g:507:112: n2= numericLiteralNegative
 17011  
                                 {
 17012  0
                                 pushFollow(FOLLOW_numericLiteralNegative_in_additiveExpression4576);
 17013  0
                                 n2=numericLiteralNegative();
 17014  
 
 17015  0
                                 state._fsp--;
 17016  
 
 17017  0
                                 stream_numericLiteralNegative.add(n2.getTree());
 17018  
 
 17019  
                                 // AST REWRITE
 17020  
                                 // elements: n2, additiveExpression
 17021  
                                 // token labels: 
 17022  
                                 // rule labels: retval, n2
 17023  
                                 // token list labels: 
 17024  
                                 // rule list labels: 
 17025  
                                 // wildcard labels: 
 17026  0
                                 retval.tree = root_0;
 17027  0
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17028  0
                                 RewriteRuleSubtreeStream stream_n2=new RewriteRuleSubtreeStream(adaptor,"rule n2",n2!=null?n2.tree:null);
 17029  
 
 17030  0
                                 root_0 = (Object)adaptor.nil();
 17031  
                                 // 507:138: -> ^( PLUS $additiveExpression $n2)
 17032  
                                 {
 17033  
                                     // com\\googlecode\\sparkleg\\Sparql.g:507:141: ^( PLUS $additiveExpression $n2)
 17034  
                                     {
 17035  0
                                     Object root_1 = (Object)adaptor.nil();
 17036  20
                                     root_1 = (Object)adaptor.becomeRoot(
 17037  20
                                     (Object)adaptor.create(PLUS, "PLUS")
 17038  
                                     , root_1);
 17039  
 
 17040  0
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17041  
 
 17042  0
                                     adaptor.addChild(root_1, stream_n2.nextTree());
 17043  
 
 17044  0
                                     adaptor.addChild(root_0, root_1);
 17045  
                                     }
 17046  
 
 17047  
                                 }
 17048  
 
 17049  
 
 17050  20
                                 retval.tree = root_0;
 17051  
 
 17052  
                                 }
 17053  
                                 break;
 17054  
 
 17055  
                         }
 17056  
 
 17057  
 
 17058  
                         // com\\googlecode\\sparkleg\\Sparql.g:508:46: ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )?
 17059  20
                         int alt121=3;
 17060  20
                         switch ( input.LA(1) ) {
 17061  
                             case ASTERISK:
 17062  
                                 {
 17063  0
                                 alt121=1;
 17064  
                                 }
 17065  0
                                 break;
 17066  
                             case DIVIDE:
 17067  
                                 {
 17068  0
                                 alt121=2;
 17069  
                                 }
 17070  
                                 break;
 17071  
                         }
 17072  
 
 17073  20
                         switch (alt121) {
 17074  
                             case 1 :
 17075  
                                 // com\\googlecode\\sparkleg\\Sparql.g:508:47: ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) )
 17076  
                                 {
 17077  
                                 // com\\googlecode\\sparkleg\\Sparql.g:508:47: ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) )
 17078  
                                 // com\\googlecode\\sparkleg\\Sparql.g:508:48: ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) )
 17079  
                                 {
 17080  
                                 // com\\googlecode\\sparkleg\\Sparql.g:508:48: ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) )
 17081  
                                 // com\\googlecode\\sparkleg\\Sparql.g:508:49: ASTERISK u2= unaryExpression
 17082  
                                 {
 17083  0
                                 ASTERISK363=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_additiveExpression4640);  
 17084  0
                                 stream_ASTERISK.add(ASTERISK363);
 17085  
 
 17086  
 
 17087  0
                                 pushFollow(FOLLOW_unaryExpression_in_additiveExpression4644);
 17088  0
                                 u2=unaryExpression();
 17089  
 
 17090  0
                                 state._fsp--;
 17091  
 
 17092  0
                                 stream_unaryExpression.add(u2.getTree());
 17093  
 
 17094  
                                 // AST REWRITE
 17095  
                                 // elements: additiveExpression, ASTERISK, u2
 17096  
                                 // token labels: 
 17097  
                                 // rule labels: retval, u2
 17098  
                                 // token list labels: 
 17099  
                                 // rule list labels: 
 17100  
                                 // wildcard labels: 
 17101  0
                                 retval.tree = root_0;
 17102  0
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17103  0
                                 RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17104  
 
 17105  0
                                 root_0 = (Object)adaptor.nil();
 17106  
                                 // 508:77: -> ^( ASTERISK $additiveExpression $u2)
 17107  
                                 {
 17108  
                                     // com\\googlecode\\sparkleg\\Sparql.g:508:80: ^( ASTERISK $additiveExpression $u2)
 17109  
                                     {
 17110  0
                                     Object root_1 = (Object)adaptor.nil();
 17111  0
                                     root_1 = (Object)adaptor.becomeRoot(
 17112  
                                     stream_ASTERISK.nextNode()
 17113  
                                     , root_1);
 17114  
 
 17115  0
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17116  
 
 17117  0
                                     adaptor.addChild(root_1, stream_u2.nextTree());
 17118  
 
 17119  0
                                     adaptor.addChild(root_0, root_1);
 17120  
                                     }
 17121  
 
 17122  
                                 }
 17123  
 
 17124  
 
 17125  0
                                 retval.tree = root_0;
 17126  
 
 17127  
                                 }
 17128  
 
 17129  
 
 17130  
                                 }
 17131  
 
 17132  
 
 17133  
                                 }
 17134  0
                                 break;
 17135  
                             case 2 :
 17136  
                                 // com\\googlecode\\sparkleg\\Sparql.g:509:48: ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) )
 17137  
                                 {
 17138  
                                 // com\\googlecode\\sparkleg\\Sparql.g:509:48: ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) )
 17139  
                                 // com\\googlecode\\sparkleg\\Sparql.g:509:49: ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) )
 17140  
                                 {
 17141  
                                 // com\\googlecode\\sparkleg\\Sparql.g:509:49: ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) )
 17142  
                                 // com\\googlecode\\sparkleg\\Sparql.g:509:50: DIVIDE u2= unaryExpression
 17143  
                                 {
 17144  0
                                 DIVIDE364=(Token)match(input,DIVIDE,FOLLOW_DIVIDE_in_additiveExpression4710);  
 17145  0
                                 stream_DIVIDE.add(DIVIDE364);
 17146  
 
 17147  
 
 17148  0
                                 pushFollow(FOLLOW_unaryExpression_in_additiveExpression4714);
 17149  0
                                 u2=unaryExpression();
 17150  
 
 17151  0
                                 state._fsp--;
 17152  
 
 17153  0
                                 stream_unaryExpression.add(u2.getTree());
 17154  
 
 17155  
                                 // AST REWRITE
 17156  
                                 // elements: additiveExpression, DIVIDE, u2
 17157  
                                 // token labels: 
 17158  
                                 // rule labels: retval, u2
 17159  
                                 // token list labels: 
 17160  
                                 // rule list labels: 
 17161  
                                 // wildcard labels: 
 17162  0
                                 retval.tree = root_0;
 17163  0
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17164  0
                                 RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17165  
 
 17166  0
                                 root_0 = (Object)adaptor.nil();
 17167  
                                 // 509:76: -> ^( DIVIDE $additiveExpression $u2)
 17168  
                                 {
 17169  
                                     // com\\googlecode\\sparkleg\\Sparql.g:509:79: ^( DIVIDE $additiveExpression $u2)
 17170  
                                     {
 17171  0
                                     Object root_1 = (Object)adaptor.nil();
 17172  0
                                     root_1 = (Object)adaptor.becomeRoot(
 17173  
                                     stream_DIVIDE.nextNode()
 17174  
                                     , root_1);
 17175  
 
 17176  0
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17177  
 
 17178  20
                                     adaptor.addChild(root_1, stream_u2.nextTree());
 17179  
 
 17180  0
                                     adaptor.addChild(root_0, root_1);
 17181  1081
                                     }
 17182  
 
 17183  73
                                 }
 17184  
 
 17185  
 
 17186  0
                                 retval.tree = root_0;
 17187  
 
 17188  1081
                                 }
 17189  
 
 17190  
 
 17191  1081
                                 }
 17192  1081
 
 17193  
 
 17194  
                                 }
 17195  
                                 break;
 17196  
 
 17197  
                         }
 17198  
 
 17199  
 
 17200  
                         }
 17201  20
                         break;
 17202  
 
 17203  
                     default :
 17204  2162
                         break loop122;
 17205  1081
                 }
 17206  73
             } while (true);
 17207  
 
 17208  
 
 17209  
             }
 17210  53
 
 17211  1081
             retval.stop = input.LT(-1);
 17212  53
 
 17213  
 
 17214  1081
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17215  1081
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17216  
 
 17217  
         }
 17218  0
         catch (RecognitionException re) {
 17219  53
             reportError(re);
 17220  53
             recover(input,re);
 17221  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17222  
 
 17223  53
         }
 17224  
 
 17225  53
         finally {
 17226  
                 // do for sure before leaving
 17227  1134
         }
 17228  1081
         return retval;
 17229  
     }
 17230  
     // $ANTLR end "additiveExpression"
 17231  
 
 17232  
 
 17233  53
     public static class additiveOperator_return extends ParserRuleReturnScope {
 17234  
         Object tree;
 17235  53
         public Object getTree() { return tree; }
 17236  53
     };
 17237  
 
 17238  53
 
 17239  53
     // $ANTLR start "additiveOperator"
 17240  53
     // com\\googlecode\\sparkleg\\Sparql.g:512:1: additiveOperator : ( PLUS | MINUS );
 17241  
     public final SparqlParser.additiveOperator_return additiveOperator() throws RecognitionException {
 17242  53
         SparqlParser.additiveOperator_return retval = new SparqlParser.additiveOperator_return();
 17243  106
         retval.start = input.LT(1);
 17244  
 
 17245  
 
 17246  53
         Object root_0 = null;
 17247  
 
 17248  53
         Token set365=null;
 17249  
 
 17250  53
         Object set365_tree=null;
 17251  
 
 17252  
         try {
 17253  53
             // com\\googlecode\\sparkleg\\Sparql.g:513:5: ( PLUS | MINUS )
 17254  
             // com\\googlecode\\sparkleg\\Sparql.g:
 17255  
             {
 17256  106
             root_0 = (Object)adaptor.nil();
 17257  53
 
 17258  
 
 17259  53
             set365=(Token)input.LT(1);
 17260  
 
 17261  53
             if ( input.LA(1)==MINUS||input.LA(1)==PLUS ) {
 17262  53
                 input.consume();
 17263  53
                 adaptor.addChild(root_0, 
 17264  
                 (Object)adaptor.create(set365)
 17265  
                 );
 17266  53
                 state.errorRecovery=false;
 17267  
             }
 17268  
             else {
 17269  53
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 17270  53
                 throw mse;
 17271  
             }
 17272  
 
 17273  
 
 17274  
             }
 17275  1134
 
 17276  53
             retval.stop = input.LT(-1);
 17277  1134
 
 17278  
 
 17279  53
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17280  53
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17281  
 
 17282  
         }
 17283  0
         catch (RecognitionException re) {
 17284  1134
             reportError(re);
 17285  1134
             recover(input,re);
 17286  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17287  
 
 17288  1134
         }
 17289  
 
 17290  1134
         finally {
 17291  
                 // do for sure before leaving
 17292  1187
         }
 17293  53
         return retval;
 17294  1134
     }
 17295  
     // $ANTLR end "additiveOperator"
 17296  
 
 17297  1134
 
 17298  1134
     public static class multiplicativeExpression_return extends ParserRuleReturnScope {
 17299  
         Object tree;
 17300  1134
         public Object getTree() { return tree; }
 17301  
     };
 17302  
 
 17303  
 
 17304  
     // $ANTLR start "multiplicativeExpression"
 17305  
     // com\\googlecode\\sparkleg\\Sparql.g:516:1: multiplicativeExpression : (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )* ;
 17306  1134
     public final SparqlParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException {
 17307  2268
         SparqlParser.multiplicativeExpression_return retval = new SparqlParser.multiplicativeExpression_return();
 17308  1134
         retval.start = input.LT(1);
 17309  1134
 
 17310  
 
 17311  2268
         Object root_0 = null;
 17312  
 
 17313  1134
         SparqlParser.unaryExpression_return u1 =null;
 17314  
 
 17315  1134
         SparqlParser.unaryExpression_return u2 =null;
 17316  
 
 17317  1134
         SparqlParser.multiplicativeOperator_return multiplicativeOperator366 =null;
 17318  
 
 17319  
 
 17320  2268
         RewriteRuleSubtreeStream stream_multiplicativeOperator=new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeOperator");
 17321  2268
         RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
 17322  1134
         try {
 17323  
             // com\\googlecode\\sparkleg\\Sparql.g:517:5: ( (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )* )
 17324  1134
             // com\\googlecode\\sparkleg\\Sparql.g:517:7: (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )*
 17325  
             {
 17326  
             // com\\googlecode\\sparkleg\\Sparql.g:517:7: (u1= unaryExpression -> $u1)
 17327  1134
             // com\\googlecode\\sparkleg\\Sparql.g:517:8: u1= unaryExpression
 17328  
             {
 17329  1134
             pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression4780);
 17330  1134
             u1=unaryExpression();
 17331  
 
 17332  2268
             state._fsp--;
 17333  
 
 17334  1134
             stream_unaryExpression.add(u1.getTree());
 17335  
 
 17336  
             // AST REWRITE
 17337  
             // elements: u1
 17338  
             // token labels: 
 17339  
             // rule labels: retval, u1
 17340  1150
             // token list labels: 
 17341  1150
             // rule list labels: 
 17342  
             // wildcard labels: 
 17343  1134
             retval.tree = root_0;
 17344  1134
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17345  1150
             RewriteRuleSubtreeStream stream_u1=new RewriteRuleSubtreeStream(adaptor,"rule u1",u1!=null?u1.tree:null);
 17346  
 
 17347  1134
             root_0 = (Object)adaptor.nil();
 17348  
             // 517:27: -> $u1
 17349  
             {
 17350  1134
                 adaptor.addChild(root_0, stream_u1.nextTree());
 17351  1150
 
 17352  
             }
 17353  
 
 17354  
 
 17355  1150
             retval.tree = root_0;
 17356  16
 
 17357  
             }
 17358  16
 
 17359  
 
 17360  16
             // com\\googlecode\\sparkleg\\Sparql.g:517:35: ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )*
 17361  
             loop123:
 17362  16
             do {
 17363  1166
                 int alt123=2;
 17364  1150
                 switch ( input.LA(1) ) {
 17365  16
                 case ASTERISK:
 17366  
                 case DIVIDE:
 17367  16
                     {
 17368  16
                     alt123=1;
 17369  
                     }
 17370  
                     break;
 17371  
 
 17372  
                 }
 17373  
 
 17374  1150
                 switch (alt123) {
 17375  
                     case 1 :
 17376  16
                         // com\\googlecode\\sparkleg\\Sparql.g:517:36: multiplicativeOperator u2= unaryExpression
 17377  16
                         {
 17378  32
                         pushFollow(FOLLOW_multiplicativeOperator_in_multiplicativeExpression4789);
 17379  16
                         multiplicativeOperator366=multiplicativeOperator();
 17380  16
 
 17381  16
                         state._fsp--;
 17382  
 
 17383  16
                         stream_multiplicativeOperator.add(multiplicativeOperator366.getTree());
 17384  
 
 17385  32
                         pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression4793);
 17386  32
                         u2=unaryExpression();
 17387  
 
 17388  32
                         state._fsp--;
 17389  
 
 17390  32
                         stream_unaryExpression.add(u2.getTree());
 17391  
 
 17392  16
                         // AST REWRITE
 17393  
                         // elements: multiplicativeOperator, u2, multiplicativeExpression
 17394  
                         // token labels: 
 17395  
                         // rule labels: retval, u2
 17396  
                         // token list labels: 
 17397  
                         // rule list labels: 
 17398  16
                         // wildcard labels: 
 17399  16
                         retval.tree = root_0;
 17400  16
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17401  32
                         RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17402  
 
 17403  16
                         root_0 = (Object)adaptor.nil();
 17404  1134
                         // 517:78: -> ^( multiplicativeOperator $multiplicativeExpression $u2)
 17405  
                         {
 17406  16
                             // com\\googlecode\\sparkleg\\Sparql.g:517:81: ^( multiplicativeOperator $multiplicativeExpression $u2)
 17407  
                             {
 17408  16
                             Object root_1 = (Object)adaptor.nil();
 17409  16
                             root_1 = (Object)adaptor.becomeRoot(stream_multiplicativeOperator.nextNode(), root_1);
 17410  
 
 17411  1150
                             adaptor.addChild(root_1, stream_retval.nextTree());
 17412  
 
 17413  16
                             adaptor.addChild(root_1, stream_u2.nextTree());
 17414  1134
 
 17415  1150
                             adaptor.addChild(root_0, root_1);
 17416  
                             }
 17417  
 
 17418  
                         }
 17419  
 
 17420  
 
 17421  16
                         retval.tree = root_0;
 17422  
 
 17423  
                         }
 17424  16
                         break;
 17425  
 
 17426  
                     default :
 17427  2268
                         break loop123;
 17428  1134
                 }
 17429  16
             } while (true);
 17430  
 
 17431  
 
 17432  
             }
 17433  16
 
 17434  1134
             retval.stop = input.LT(-1);
 17435  16
 
 17436  
 
 17437  1134
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17438  1134
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17439  
 
 17440  
         }
 17441  0
         catch (RecognitionException re) {
 17442  16
             reportError(re);
 17443  16
             recover(input,re);
 17444  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17445  
 
 17446  16
         }
 17447  
 
 17448  16
         finally {
 17449  
                 // do for sure before leaving
 17450  1150
         }
 17451  1134
         return retval;
 17452  
     }
 17453  
     // $ANTLR end "multiplicativeExpression"
 17454  
 
 17455  
 
 17456  16
     public static class multiplicativeOperator_return extends ParserRuleReturnScope {
 17457  
         Object tree;
 17458  16
         public Object getTree() { return tree; }
 17459  16
     };
 17460  
 
 17461  16
 
 17462  16
     // $ANTLR start "multiplicativeOperator"
 17463  16
     // com\\googlecode\\sparkleg\\Sparql.g:520:1: multiplicativeOperator : ( ASTERISK | DIVIDE );
 17464  
     public final SparqlParser.multiplicativeOperator_return multiplicativeOperator() throws RecognitionException {
 17465  16
         SparqlParser.multiplicativeOperator_return retval = new SparqlParser.multiplicativeOperator_return();
 17466  32
         retval.start = input.LT(1);
 17467  
 
 17468  
 
 17469  16
         Object root_0 = null;
 17470  
 
 17471  16
         Token set367=null;
 17472  
 
 17473  16
         Object set367_tree=null;
 17474  
 
 17475  
         try {
 17476  16
             // com\\googlecode\\sparkleg\\Sparql.g:521:5: ( ASTERISK | DIVIDE )
 17477  
             // com\\googlecode\\sparkleg\\Sparql.g:
 17478  
             {
 17479  32
             root_0 = (Object)adaptor.nil();
 17480  16
 
 17481  
 
 17482  16
             set367=(Token)input.LT(1);
 17483  
 
 17484  16
             if ( input.LA(1)==ASTERISK||input.LA(1)==DIVIDE ) {
 17485  16
                 input.consume();
 17486  16
                 adaptor.addChild(root_0, 
 17487  
                 (Object)adaptor.create(set367)
 17488  
                 );
 17489  16
                 state.errorRecovery=false;
 17490  
             }
 17491  
             else {
 17492  16
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 17493  16
                 throw mse;
 17494  
             }
 17495  
 
 17496  
 
 17497  
             }
 17498  1150
 
 17499  16
             retval.stop = input.LT(-1);
 17500  1150
 
 17501  
 
 17502  16
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17503  16
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17504  
 
 17505  
         }
 17506  0
         catch (RecognitionException re) {
 17507  1150
             reportError(re);
 17508  1150
             recover(input,re);
 17509  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17510  
 
 17511  1150
         }
 17512  
 
 17513  1150
         finally {
 17514  1150
                 // do for sure before leaving
 17515  1166
         }
 17516  1166
         return retval;
 17517  
     }
 17518  1150
     // $ANTLR end "multiplicativeOperator"
 17519  
 
 17520  1150
 
 17521  1150
     public static class unaryExpression_return extends ParserRuleReturnScope {
 17522  1150
         Object tree;
 17523  1150
         public Object getTree() { return tree; }
 17524  
     };
 17525  1150
 
 17526  1150
 
 17527  1150
     // $ANTLR start "unaryExpression"
 17528  1150
     // com\\googlecode\\sparkleg\\Sparql.g:524:1: unaryExpression : ( NEGATION primaryExpression -> ^( UNARY NEGATION primaryExpression ) | PLUS primaryExpression -> ^( UNARY PLUS primaryExpression ) | MINUS primaryExpression -> ^( UNARY MINUS primaryExpression ) | primaryExpression -> ^( UNARY primaryExpression ) );
 17529  1150
     public final SparqlParser.unaryExpression_return unaryExpression() throws RecognitionException {
 17530  2300
         SparqlParser.unaryExpression_return retval = new SparqlParser.unaryExpression_return();
 17531  2300
         retval.start = input.LT(1);
 17532  
 
 17533  
 
 17534  2300
         Object root_0 = null;
 17535  1150
 
 17536  1150
         Token NEGATION368=null;
 17537  1150
         Token PLUS370=null;
 17538  1169
         Token MINUS372=null;
 17539  1150
         SparqlParser.primaryExpression_return primaryExpression369 =null;
 17540  19
 
 17541  1150
         SparqlParser.primaryExpression_return primaryExpression371 =null;
 17542  
 
 17543  1150
         SparqlParser.primaryExpression_return primaryExpression373 =null;
 17544  
 
 17545  1150
         SparqlParser.primaryExpression_return primaryExpression374 =null;
 17546  
 
 17547  
 
 17548  1151
         Object NEGATION368_tree=null;
 17549  1150
         Object PLUS370_tree=null;
 17550  1151
         Object MINUS372_tree=null;
 17551  1150
         RewriteRuleTokenStream stream_PLUS=new RewriteRuleTokenStream(adaptor,"token PLUS");
 17552  1150
         RewriteRuleTokenStream stream_NEGATION=new RewriteRuleTokenStream(adaptor,"token NEGATION");
 17553  1150
         RewriteRuleTokenStream stream_MINUS=new RewriteRuleTokenStream(adaptor,"token MINUS");
 17554  1150
         RewriteRuleSubtreeStream stream_primaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule primaryExpression");
 17555  
         try {
 17556  
             // com\\googlecode\\sparkleg\\Sparql.g:525:5: ( NEGATION primaryExpression -> ^( UNARY NEGATION primaryExpression ) | PLUS primaryExpression -> ^( UNARY PLUS primaryExpression ) | MINUS primaryExpression -> ^( UNARY MINUS primaryExpression ) | primaryExpression -> ^( UNARY primaryExpression ) )
 17557  1150
             int alt124=4;
 17558  1150
             switch ( input.LA(1) ) {
 17559  
             case NEGATION:
 17560  
                 {
 17561  19
                 alt124=1;
 17562  
                 }
 17563  19
                 break;
 17564  
             case PLUS:
 17565  
                 {
 17566  0
                 alt124=2;
 17567  
                 }
 17568  0
                 break;
 17569  
             case MINUS:
 17570  
                 {
 17571  1
                 alt124=3;
 17572  
                 }
 17573  1
                 break;
 17574  
             case ABS:
 17575  
             case AVG:
 17576  
             case BNODE:
 17577  
             case BOUND:
 17578  
             case CEIL:
 17579  
             case COALESCE:
 17580  
             case CONCAT:
 17581  
             case CONTAINS:
 17582  
             case COUNT:
 17583  
             case DATATYPE:
 17584  
             case DAY:
 17585  
             case DECIMAL:
 17586  
             case DECIMAL_NEGATIVE:
 17587  
             case DECIMAL_POSITIVE:
 17588  
             case DOUBLE:
 17589  
             case DOUBLE_NEGATIVE:
 17590  
             case DOUBLE_POSITIVE:
 17591  
             case ENCODE_FOR_URI:
 17592  
             case EXISTS:
 17593  
             case FALSE:
 17594  
             case FLOOR:
 17595  
             case GROUP_CONCAT:
 17596  
             case HOURS:
 17597  
             case IF:
 17598  
             case INTEGER:
 17599  
             case INTEGER_NEGATIVE:
 17600  
             case INTEGER_POSITIVE:
 17601  
             case IRI:
 17602  
             case IRI_REF:
 17603  
             case ISBLANK:
 17604  
             case ISIRI:
 17605  
             case ISLITERAL:
 17606  
             case ISNUMERIC:
 17607  
             case ISURI:
 17608  
             case LANG:
 17609  
             case LANGMATCHES:
 17610  
             case LCASE:
 17611  
             case MAX:
 17612  
             case MD5:
 17613  
             case MIN:
 17614  
             case MINUTES:
 17615  
             case MONTH:
 17616  
             case NOT:
 17617  
             case NOW:
 17618  
             case OPEN_BRACE:
 17619  
             case PNAME_LN:
 17620  
             case PNAME_NS:
 17621  
             case RAND:
 17622  
             case REGEX:
 17623  
             case REPLACE:
 17624  
             case ROUND:
 17625  
             case SAMETERM:
 17626  
             case SAMPLE:
 17627  
             case SECONDS:
 17628  
             case SHA1:
 17629  
             case SHA224:
 17630  
             case SHA256:
 17631  
             case SHA384:
 17632  
             case SHA512:
 17633  1128
             case STR:
 17634  
             case STRAFTER:
 17635  1128
             case STRBEFORE:
 17636  
             case STRDT:
 17637  2
             case STRENDS:
 17638  
             case STRING_LITERAL1:
 17639  
             case STRING_LITERAL2:
 17640  2
             case STRING_LITERAL_LONG1:
 17641  
             case STRING_LITERAL_LONG2:
 17642  
             case STRLANG:
 17643  
             case STRLEN:
 17644  1148
             case STRSTARTS:
 17645  
             case SUBSTR:
 17646  
             case SUM:
 17647  
             case TIMEZONE:
 17648  19
             case TRUE:
 17649  19
             case TZ:
 17650  
             case UCASE:
 17651  
             case URI:
 17652  19
             case VAR1:
 17653  19
             case VAR2:
 17654  
             case YEAR:
 17655  19
                 {
 17656  1128
                 alt124=4;
 17657  19
                 }
 17658  1128
                 break;
 17659  
             default:
 17660  2
                 NoViableAltException nvae =
 17661  
                     new NoViableAltException("", 124, 0, input);
 17662  
 
 17663  2
                 throw nvae;
 17664  
 
 17665  
             }
 17666  19
 
 17667  1167
             switch (alt124) {
 17668  
                 case 1 :
 17669  19
                     // com\\googlecode\\sparkleg\\Sparql.g:525:7: NEGATION primaryExpression
 17670  
                     {
 17671  19
                     NEGATION368=(Token)match(input,NEGATION,FOLLOW_NEGATION_in_unaryExpression4849);  
 17672  19
                     stream_NEGATION.add(NEGATION368);
 17673  
 
 17674  19
 
 17675  38
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4851);
 17676  19
                     primaryExpression369=primaryExpression();
 17677  
 
 17678  19
                     state._fsp--;
 17679  19
 
 17680  19
                     stream_primaryExpression.add(primaryExpression369.getTree());
 17681  
 
 17682  
                     // AST REWRITE
 17683  19
                     // elements: NEGATION, primaryExpression
 17684  
                     // token labels: 
 17685  19
                     // rule labels: retval
 17686  
                     // token list labels: 
 17687  
                     // rule list labels: 
 17688  
                     // wildcard labels: 
 17689  19
                     retval.tree = root_0;
 17690  19
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17691  19
 
 17692  19
                     root_0 = (Object)adaptor.nil();
 17693  
                     // 525:34: -> ^( UNARY NEGATION primaryExpression )
 17694  19
                     {
 17695  
                         // com\\googlecode\\sparkleg\\Sparql.g:525:37: ^( UNARY NEGATION primaryExpression )
 17696  
                         {
 17697  19
                         Object root_1 = (Object)adaptor.nil();
 17698  19
                         root_1 = (Object)adaptor.becomeRoot(
 17699  
                         (Object)adaptor.create(UNARY, "UNARY")
 17700  
                         , root_1);
 17701  
 
 17702  19
                         adaptor.addChild(root_1, 
 17703  
                         stream_NEGATION.nextNode()
 17704  
                         );
 17705  
 
 17706  19
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17707  
 
 17708  19
                         adaptor.addChild(root_0, root_1);
 17709  
                         }
 17710  
 
 17711  
                     }
 17712  
 
 17713  
 
 17714  19
                     retval.tree = root_0;
 17715  
 
 17716  
                     }
 17717  19
                     break;
 17718  
                 case 2 :
 17719  
                     // com\\googlecode\\sparkleg\\Sparql.g:526:7: PLUS primaryExpression
 17720  
                     {
 17721  0
                     PLUS370=(Token)match(input,PLUS,FOLLOW_PLUS_in_unaryExpression4869);  
 17722  0
                     stream_PLUS.add(PLUS370);
 17723  
 
 17724  
 
 17725  0
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4871);
 17726  0
                     primaryExpression371=primaryExpression();
 17727  
 
 17728  0
                     state._fsp--;
 17729  
 
 17730  0
                     stream_primaryExpression.add(primaryExpression371.getTree());
 17731  
 
 17732  
                     // AST REWRITE
 17733  
                     // elements: primaryExpression, PLUS
 17734  
                     // token labels: 
 17735  
                     // rule labels: retval
 17736  
                     // token list labels: 
 17737  
                     // rule list labels: 
 17738  
                     // wildcard labels: 
 17739  0
                     retval.tree = root_0;
 17740  0
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17741  
 
 17742  0
                     root_0 = (Object)adaptor.nil();
 17743  
                     // 526:30: -> ^( UNARY PLUS primaryExpression )
 17744  
                     {
 17745  
                         // com\\googlecode\\sparkleg\\Sparql.g:526:33: ^( UNARY PLUS primaryExpression )
 17746  
                         {
 17747  0
                         Object root_1 = (Object)adaptor.nil();
 17748  1
                         root_1 = (Object)adaptor.becomeRoot(
 17749  1
                         (Object)adaptor.create(UNARY, "UNARY")
 17750  
                         , root_1);
 17751  
 
 17752  1
                         adaptor.addChild(root_1, 
 17753  1
                         stream_PLUS.nextNode()
 17754  
                         );
 17755  1
 
 17756  0
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17757  1
 
 17758  0
                         adaptor.addChild(root_0, root_1);
 17759  
                         }
 17760  
 
 17761  
                     }
 17762  
 
 17763  
 
 17764  0
                     retval.tree = root_0;
 17765  
 
 17766  1
                     }
 17767  1
                     break;
 17768  
                 case 3 :
 17769  1
                     // com\\googlecode\\sparkleg\\Sparql.g:527:7: MINUS primaryExpression
 17770  
                     {
 17771  1
                     MINUS372=(Token)match(input,MINUS,FOLLOW_MINUS_in_unaryExpression4889);  
 17772  1
                     stream_MINUS.add(MINUS372);
 17773  
 
 17774  1
 
 17775  2
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4891);
 17776  1
                     primaryExpression373=primaryExpression();
 17777  
 
 17778  1
                     state._fsp--;
 17779  1
 
 17780  1
                     stream_primaryExpression.add(primaryExpression373.getTree());
 17781  
 
 17782  
                     // AST REWRITE
 17783  1
                     // elements: primaryExpression, MINUS
 17784  
                     // token labels: 
 17785  1
                     // rule labels: retval
 17786  
                     // token list labels: 
 17787  
                     // rule list labels: 
 17788  
                     // wildcard labels: 
 17789  1
                     retval.tree = root_0;
 17790  1
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17791  1
 
 17792  1
                     root_0 = (Object)adaptor.nil();
 17793  
                     // 527:31: -> ^( UNARY MINUS primaryExpression )
 17794  1
                     {
 17795  
                         // com\\googlecode\\sparkleg\\Sparql.g:527:34: ^( UNARY MINUS primaryExpression )
 17796  
                         {
 17797  1
                         Object root_1 = (Object)adaptor.nil();
 17798  1129
                         root_1 = (Object)adaptor.becomeRoot(
 17799  1128
                         (Object)adaptor.create(UNARY, "UNARY")
 17800  
                         , root_1);
 17801  1128
 
 17802  1
                         adaptor.addChild(root_1, 
 17803  1128
                         stream_MINUS.nextNode()
 17804  
                         );
 17805  
 
 17806  1
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17807  
 
 17808  1
                         adaptor.addChild(root_0, root_1);
 17809  
                         }
 17810  
 
 17811  
                     }
 17812  1128
 
 17813  1128
 
 17814  1
                     retval.tree = root_0;
 17815  1128
 
 17816  
                     }
 17817  1
                     break;
 17818  
                 case 4 :
 17819  
                     // com\\googlecode\\sparkleg\\Sparql.g:528:7: primaryExpression
 17820  1128
                     {
 17821  2256
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4909);
 17822  1128
                     primaryExpression374=primaryExpression();
 17823  
 
 17824  1128
                     state._fsp--;
 17825  1128
 
 17826  1128
                     stream_primaryExpression.add(primaryExpression374.getTree());
 17827  1128
 
 17828  
                     // AST REWRITE
 17829  
                     // elements: primaryExpression
 17830  
                     // token labels: 
 17831  
                     // rule labels: retval
 17832  
                     // token list labels: 
 17833  1128
                     // rule list labels: 
 17834  
                     // wildcard labels: 
 17835  1128
                     retval.tree = root_0;
 17836  1128
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17837  
 
 17838  1128
                     root_0 = (Object)adaptor.nil();
 17839  1148
                     // 528:25: -> ^( UNARY primaryExpression )
 17840  
                     {
 17841  
                         // com\\googlecode\\sparkleg\\Sparql.g:528:28: ^( UNARY primaryExpression )
 17842  1148
                         {
 17843  2276
                         Object root_1 = (Object)adaptor.nil();
 17844  1128
                         root_1 = (Object)adaptor.becomeRoot(
 17845  
                         (Object)adaptor.create(UNARY, "UNARY")
 17846  2
                         , root_1);
 17847  2
 
 17848  1130
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17849  2
 
 17850  1128
                         adaptor.addChild(root_0, root_1);
 17851  
                         }
 17852  
 
 17853  
                     }
 17854  
 
 17855  1150
 
 17856  2278
                     retval.tree = root_0;
 17857  
 
 17858  
                     }
 17859  
                     break;
 17860  
 
 17861  1148
             }
 17862  1148
             retval.stop = input.LT(-1);
 17863  1148
 
 17864  
 
 17865  1148
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17866  1148
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17867  
 
 17868  
         }
 17869  2
         catch (RecognitionException re) {
 17870  1150
             reportError(re);
 17871  1150
             recover(input,re);
 17872  2
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17873  
 
 17874  1148
         }
 17875  
 
 17876  1148
         finally {
 17877  
                 // do for sure before leaving
 17878  2298
         }
 17879  1150
         return retval;
 17880  1148
     }
 17881  
     // $ANTLR end "unaryExpression"
 17882  1148
 
 17883  
 
 17884  1148
     public static class primaryExpression_return extends ParserRuleReturnScope {
 17885  
         Object tree;
 17886  1148
         public Object getTree() { return tree; }
 17887  
     };
 17888  1148
 
 17889  
 
 17890  1148
     // $ANTLR start "primaryExpression"
 17891  
     // com\\googlecode\\sparkleg\\Sparql.g:531:1: primaryExpression : ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate );
 17892  
     public final SparqlParser.primaryExpression_return primaryExpression() throws RecognitionException {
 17893  1148
         SparqlParser.primaryExpression_return retval = new SparqlParser.primaryExpression_return();
 17894  1148
         retval.start = input.LT(1);
 17895  
 
 17896  1148
 
 17897  2296
         Object root_0 = null;
 17898  
 
 17899  1148
         SparqlParser.brackettedExpression_return brackettedExpression375 =null;
 17900  24
 
 17901  1148
         SparqlParser.builtInCall_return builtInCall376 =null;
 17902  24
 
 17903  1148
         SparqlParser.iriRefOrFunction_return iriRefOrFunction377 =null;
 17904  
 
 17905  1148
         SparqlParser.rdfLiteral_return rdfLiteral378 =null;
 17906  
 
 17907  1148
         SparqlParser.numericLiteral_return numericLiteral379 =null;
 17908  
 
 17909  1148
         SparqlParser.booleanLiteral_return booleanLiteral380 =null;
 17910  
 
 17911  1148
         SparqlParser.var_return var381 =null;
 17912  
 
 17913  1148
         SparqlParser.aggregate_return aggregate382 =null;
 17914  
 
 17915  
 
 17916  
 
 17917  
         try {
 17918  
             // com\\googlecode\\sparkleg\\Sparql.g:532:5: ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate )
 17919  1148
             int alt125=8;
 17920  1148
             switch ( input.LA(1) ) {
 17921  
             case OPEN_BRACE:
 17922  
                 {
 17923  24
                 alt125=1;
 17924  
                 }
 17925  24
                 break;
 17926  
             case ABS:
 17927  
             case BNODE:
 17928  
             case BOUND:
 17929  
             case CEIL:
 17930  
             case COALESCE:
 17931  
             case CONCAT:
 17932  
             case CONTAINS:
 17933  
             case DATATYPE:
 17934  
             case DAY:
 17935  
             case ENCODE_FOR_URI:
 17936  
             case EXISTS:
 17937  
             case FLOOR:
 17938  
             case HOURS:
 17939  
             case IF:
 17940  
             case IRI:
 17941  
             case ISBLANK:
 17942  
             case ISIRI:
 17943  
             case ISLITERAL:
 17944  
             case ISNUMERIC:
 17945  
             case ISURI:
 17946  
             case LANG:
 17947  
             case LANGMATCHES:
 17948  
             case LCASE:
 17949  
             case MD5:
 17950  
             case MINUTES:
 17951  
             case MONTH:
 17952  
             case NOT:
 17953  
             case NOW:
 17954  
             case RAND:
 17955  
             case REGEX:
 17956  
             case REPLACE:
 17957  187
             case ROUND:
 17958  
             case SAMETERM:
 17959  187
             case SECONDS:
 17960  
             case SHA1:
 17961  
             case SHA224:
 17962  
             case SHA256:
 17963  
             case SHA384:
 17964  89
             case SHA512:
 17965  
             case STR:
 17966  89
             case STRAFTER:
 17967  
             case STRBEFORE:
 17968  
             case STRDT:
 17969  
             case STRENDS:
 17970  
             case STRLANG:
 17971  
             case STRLEN:
 17972  104
             case STRSTARTS:
 17973  
             case SUBSTR:
 17974  104
             case TIMEZONE:
 17975  
             case TZ:
 17976  
             case UCASE:
 17977  
             case URI:
 17978  
             case YEAR:
 17979  
                 {
 17980  187
                 alt125=2;
 17981  
                 }
 17982  187
                 break;
 17983  
             case IRI_REF:
 17984  
             case PNAME_LN:
 17985  93
             case PNAME_NS:
 17986  
                 {
 17987  182
                 alt125=3;
 17988  
                 }
 17989  89
                 break;
 17990  
             case STRING_LITERAL1:
 17991  6
             case STRING_LITERAL2:
 17992  
             case STRING_LITERAL_LONG1:
 17993  6
             case STRING_LITERAL_LONG2:
 17994  
                 {
 17995  104
                 alt125=4;
 17996  
                 }
 17997  696
                 break;
 17998  
             case DECIMAL:
 17999  592
             case DECIMAL_NEGATIVE:
 18000  
             case DECIMAL_POSITIVE:
 18001  
             case DOUBLE:
 18002  
             case DOUBLE_NEGATIVE:
 18003  
             case DOUBLE_POSITIVE:
 18004  
             case INTEGER:
 18005  
             case INTEGER_NEGATIVE:
 18006  
             case INTEGER_POSITIVE:
 18007  
                 {
 18008  146
                 alt125=5;
 18009  
                 }
 18010  146
                 break;
 18011  
             case FALSE:
 18012  
             case TRUE:
 18013  
                 {
 18014  6
                 alt125=6;
 18015  
                 }
 18016  6
                 break;
 18017  
             case VAR1:
 18018  
             case VAR2:
 18019  1148
                 {
 18020  592
                 alt125=7;
 18021  
                 }
 18022  592
                 break;
 18023  24
             case AVG:
 18024  
             case COUNT:
 18025  
             case GROUP_CONCAT:
 18026  24
             case MAX:
 18027  24
             case MIN:
 18028  
             case SAMPLE:
 18029  24
             case SUM:
 18030  
                 {
 18031  77
                 alt125=8;
 18032  
                 }
 18033  53
                 break;
 18034  24
             default:
 18035  0
                 NoViableAltException nvae =
 18036  
                     new NoViableAltException("", 125, 0, input);
 18037  
 
 18038  187
                 throw nvae;
 18039  
 
 18040  
             }
 18041  187
 
 18042  1335
             switch (alt125) {
 18043  
                 case 1 :
 18044  187
                     // com\\googlecode\\sparkleg\\Sparql.g:532:7: brackettedExpression
 18045  
                     {
 18046  211
                     root_0 = (Object)adaptor.nil();
 18047  
 
 18048  
 
 18049  211
                     pushFollow(FOLLOW_brackettedExpression_in_primaryExpression4934);
 18050  24
                     brackettedExpression375=brackettedExpression();
 18051  
 
 18052  24
                     state._fsp--;
 18053  89
 
 18054  24
                     adaptor.addChild(root_0, brackettedExpression375.getTree());
 18055  
 
 18056  89
                     }
 18057  113
                     break;
 18058  
                 case 2 :
 18059  89
                     // com\\googlecode\\sparkleg\\Sparql.g:532:30: builtInCall
 18060  
                     {
 18061  276
                     root_0 = (Object)adaptor.nil();
 18062  
 
 18063  
 
 18064  276
                     pushFollow(FOLLOW_builtInCall_in_primaryExpression4938);
 18065  187
                     builtInCall376=builtInCall();
 18066  
 
 18067  187
                     state._fsp--;
 18068  104
 
 18069  187
                     adaptor.addChild(root_0, builtInCall376.getTree());
 18070  
 
 18071  104
                     }
 18072  291
                     break;
 18073  
                 case 3 :
 18074  104
                     // com\\googlecode\\sparkleg\\Sparql.g:532:44: iriRefOrFunction
 18075  
                     {
 18076  193
                     root_0 = (Object)adaptor.nil();
 18077  
 
 18078  
 
 18079  193
                     pushFollow(FOLLOW_iriRefOrFunction_in_primaryExpression4942);
 18080  89
                     iriRefOrFunction377=iriRefOrFunction();
 18081  
 
 18082  89
                     state._fsp--;
 18083  93
 
 18084  89
                     adaptor.addChild(root_0, iriRefOrFunction377.getTree());
 18085  
 
 18086  93
                     }
 18087  182
                     break;
 18088  
                 case 4 :
 18089  93
                     // com\\googlecode\\sparkleg\\Sparql.g:532:63: rdfLiteral
 18090  
                     {
 18091  197
                     root_0 = (Object)adaptor.nil();
 18092  
 
 18093  
 
 18094  197
                     pushFollow(FOLLOW_rdfLiteral_in_primaryExpression4946);
 18095  104
                     rdfLiteral378=rdfLiteral();
 18096  
 
 18097  104
                     state._fsp--;
 18098  6
 
 18099  104
                     adaptor.addChild(root_0, rdfLiteral378.getTree());
 18100  
 
 18101  6
                     }
 18102  110
                     break;
 18103  
                 case 5 :
 18104  6
                     // com\\googlecode\\sparkleg\\Sparql.g:532:76: numericLiteral
 18105  
                     {
 18106  99
                     root_0 = (Object)adaptor.nil();
 18107  
 
 18108  
 
 18109  99
                     pushFollow(FOLLOW_numericLiteral_in_primaryExpression4950);
 18110  93
                     numericLiteral379=numericLiteral();
 18111  
 
 18112  93
                     state._fsp--;
 18113  592
 
 18114  93
                     adaptor.addChild(root_0, numericLiteral379.getTree());
 18115  
 
 18116  592
                     }
 18117  685
                     break;
 18118  
                 case 6 :
 18119  592
                     // com\\googlecode\\sparkleg\\Sparql.g:532:93: booleanLiteral
 18120  
                     {
 18121  598
                     root_0 = (Object)adaptor.nil();
 18122  
 
 18123  
 
 18124  598
                     pushFollow(FOLLOW_booleanLiteral_in_primaryExpression4954);
 18125  6
                     booleanLiteral380=booleanLiteral();
 18126  
 
 18127  6
                     state._fsp--;
 18128  53
 
 18129  6
                     adaptor.addChild(root_0, booleanLiteral380.getTree());
 18130  
 
 18131  53
                     }
 18132  59
                     break;
 18133  
                 case 7 :
 18134  53
                     // com\\googlecode\\sparkleg\\Sparql.g:532:110: var
 18135  
                     {
 18136  645
                     root_0 = (Object)adaptor.nil();
 18137  
 
 18138  
 
 18139  592
                     pushFollow(FOLLOW_var_in_primaryExpression4958);
 18140  592
                     var381=var();
 18141  
 
 18142  1740
                     state._fsp--;
 18143  
 
 18144  592
                     adaptor.addChild(root_0, var381.getTree());
 18145  1148
 
 18146  1148
                     }
 18147  592
                     break;
 18148  
                 case 8 :
 18149  
                     // com\\googlecode\\sparkleg\\Sparql.g:532:116: aggregate
 18150  
                     {
 18151  53
                     root_0 = (Object)adaptor.nil();
 18152  
 
 18153  
 
 18154  53
                     pushFollow(FOLLOW_aggregate_in_primaryExpression4962);
 18155  53
                     aggregate382=aggregate();
 18156  
 
 18157  53
                     state._fsp--;
 18158  1148
 
 18159  1201
                     adaptor.addChild(root_0, aggregate382.getTree());
 18160  
 
 18161  
                     }
 18162  
                     break;
 18163  
 
 18164  273
             }
 18165  1148
             retval.stop = input.LT(-1);
 18166  273
 
 18167  
 
 18168  1148
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18169  1148
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18170  
 
 18171  
         }
 18172  0
         catch (RecognitionException re) {
 18173  273
             reportError(re);
 18174  273
             recover(input,re);
 18175  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18176  
 
 18177  273
         }
 18178  
 
 18179  273
         finally {
 18180  273
                 // do for sure before leaving
 18181  1421
         }
 18182  1148
         return retval;
 18183  
     }
 18184  273
     // $ANTLR end "primaryExpression"
 18185  273
 
 18186  273
 
 18187  273
     public static class brackettedExpression_return extends ParserRuleReturnScope {
 18188  273
         Object tree;
 18189  273
         public Object getTree() { return tree; }
 18190  
     };
 18191  
 
 18192  
 
 18193  273
     // $ANTLR start "brackettedExpression"
 18194  273
     // com\\googlecode\\sparkleg\\Sparql.g:535:1: brackettedExpression : OPEN_BRACE expression CLOSE_BRACE -> ^( BRACKETTED_EXPRESSION expression ) ;
 18195  
     public final SparqlParser.brackettedExpression_return brackettedExpression() throws RecognitionException {
 18196  273
         SparqlParser.brackettedExpression_return retval = new SparqlParser.brackettedExpression_return();
 18197  546
         retval.start = input.LT(1);
 18198  273
 
 18199  
 
 18200  546
         Object root_0 = null;
 18201  
 
 18202  546
         Token OPEN_BRACE383=null;
 18203  273
         Token CLOSE_BRACE385=null;
 18204  546
         SparqlParser.expression_return expression384 =null;
 18205  273
 
 18206  
 
 18207  273
         Object OPEN_BRACE383_tree=null;
 18208  273
         Object CLOSE_BRACE385_tree=null;
 18209  273
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 18210  273
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 18211  273
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 18212  
         try {
 18213  
             // com\\googlecode\\sparkleg\\Sparql.g:536:5: ( OPEN_BRACE expression CLOSE_BRACE -> ^( BRACKETTED_EXPRESSION expression ) )
 18214  
             // com\\googlecode\\sparkleg\\Sparql.g:536:7: OPEN_BRACE expression CLOSE_BRACE
 18215  273
             {
 18216  546
             OPEN_BRACE383=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_brackettedExpression4979);  
 18217  273
             stream_OPEN_BRACE.add(OPEN_BRACE383);
 18218  273
 
 18219  
 
 18220  273
             pushFollow(FOLLOW_expression_in_brackettedExpression4981);
 18221  273
             expression384=expression();
 18222  
 
 18223  546
             state._fsp--;
 18224  273
 
 18225  273
             stream_expression.add(expression384.getTree());
 18226  
 
 18227  273
             CLOSE_BRACE385=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_brackettedExpression4983);  
 18228  546
             stream_CLOSE_BRACE.add(CLOSE_BRACE385);
 18229  
 
 18230  273
 
 18231  
             // AST REWRITE
 18232  
             // elements: expression
 18233  
             // token labels: 
 18234  
             // rule labels: retval
 18235  
             // token list labels: 
 18236  273
             // rule list labels: 
 18237  
             // wildcard labels: 
 18238  273
             retval.tree = root_0;
 18239  273
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18240  273
 
 18241  273
             root_0 = (Object)adaptor.nil();
 18242  
             // 536:41: -> ^( BRACKETTED_EXPRESSION expression )
 18243  273
             {
 18244  273
                 // com\\googlecode\\sparkleg\\Sparql.g:536:44: ^( BRACKETTED_EXPRESSION expression )
 18245  
                 {
 18246  273
                 Object root_1 = (Object)adaptor.nil();
 18247  273
                 root_1 = (Object)adaptor.becomeRoot(
 18248  
                 (Object)adaptor.create(BRACKETTED_EXPRESSION, "BRACKETTED_EXPRESSION")
 18249  
                 , root_1);
 18250  
 
 18251  273
                 adaptor.addChild(root_1, stream_expression.nextTree());
 18252  
 
 18253  273
                 adaptor.addChild(root_0, root_1);
 18254  
                 }
 18255  
 
 18256  273
             }
 18257  273
 
 18258  
 
 18259  273
             retval.tree = root_0;
 18260  
 
 18261  
             }
 18262  266
 
 18263  273
             retval.stop = input.LT(-1);
 18264  266
 
 18265  
 
 18266  273
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18267  273
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18268  
 
 18269  
         }
 18270  0
         catch (RecognitionException re) {
 18271  266
             reportError(re);
 18272  266
             recover(input,re);
 18273  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18274  
 
 18275  266
         }
 18276  
 
 18277  266
         finally {
 18278  266
                 // do for sure before leaving
 18279  539
         }
 18280  539
         return retval;
 18281  266
     }
 18282  266
     // $ANTLR end "brackettedExpression"
 18283  266
 
 18284  266
 
 18285  266
     public static class builtInCall_return extends ParserRuleReturnScope {
 18286  266
         Object tree;
 18287  266
         public Object getTree() { return tree; }
 18288  266
     };
 18289  266
 
 18290  266
 
 18291  266
     // $ANTLR start "builtInCall"
 18292  266
     // com\\googlecode\\sparkleg\\Sparql.g:539:1: builtInCall : ( STR OPEN_BRACE expression CLOSE_BRACE -> ^( STR expression ) | LANG OPEN_BRACE expression CLOSE_BRACE -> ^( LANG expression ) | LANGMATCHES OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( LANGMATCHES ( expression )+ ) | DATATYPE OPEN_BRACE expression CLOSE_BRACE -> ^( DATATYPE expression ) | BOUND OPEN_BRACE var CLOSE_BRACE -> ^( BOUND var ) | IRI OPEN_BRACE expression CLOSE_BRACE -> ^( IRI expression ) | URI OPEN_BRACE expression CLOSE_BRACE -> ^( URI expression ) | BNODE ( OPEN_BRACE expression CLOSE_BRACE ) -> ^( BNODE expression ) | BNODE nil -> BNODE | RAND nil -> RAND | ABS OPEN_BRACE expression CLOSE_BRACE -> ^( ABS expression ) | CEIL OPEN_BRACE expression CLOSE_BRACE -> ^( CEIL expression ) | FLOOR OPEN_BRACE expression CLOSE_BRACE -> ^( FLOOR expression ) | ROUND OPEN_BRACE expression CLOSE_BRACE -> ^( ROUND expression ) | CONCAT expressionList -> ^( CONCAT expressionList ) | subStringExpression -> subStringExpression | STRLEN OPEN_BRACE expression CLOSE_BRACE -> ^( STRLEN expression ) | UCASE OPEN_BRACE expression CLOSE_BRACE -> ^( UCASE expression ) | LCASE OPEN_BRACE expression CLOSE_BRACE -> ^( LCASE expression ) | ENCODE_FOR_URI OPEN_BRACE expression CLOSE_BRACE -> ^( ENCODE_FOR_URI expression ) | CONTAINS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( CONTAINS expression expression ) | STRSTARTS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRSTARTS expression expression ) | STRENDS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRENDS expression expression ) | STRBEFORE OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRBEFORE expression expression ) | STRAFTER OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRAFTER expression expression ) | REPLACE OPEN_BRACE expression COMMA expression COMMA expression CLOSE_BRACE -> ^( REPLACE expression expression expression ) | YEAR OPEN_BRACE expression CLOSE_BRACE -> ^( YEAR expression ) | MONTH OPEN_BRACE expression CLOSE_BRACE -> ^( MONTH expression ) | DAY OPEN_BRACE expression CLOSE_BRACE -> ^( DAY expression ) | HOURS OPEN_BRACE expression CLOSE_BRACE -> ^( HOURS expression ) | MINUTES OPEN_BRACE expression CLOSE_BRACE -> ^( MINUTES expression ) | SECONDS OPEN_BRACE expression CLOSE_BRACE -> ^( SECONDS expression ) | TIMEZONE OPEN_BRACE expression CLOSE_BRACE -> ^( TIMEZONE expression ) | TZ OPEN_BRACE expression CLOSE_BRACE -> ^( TZ expression ) | NOW nil -> NOW | MD5 OPEN_BRACE expression CLOSE_BRACE -> ^( MD5 expression ) | SHA1 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA1 expression ) | SHA224 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA224 expression ) | SHA256 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA256 expression ) | SHA384 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA384 expression ) | SHA512 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA512 expression ) | COALESCE expressionList -> ^( COALESCE expressionList ) | IF OPEN_BRACE e1= expression COMMA e2= expression COMMA e3= expression CLOSE_BRACE -> ^( IF $e1 $e2 $e3) | STRLANG OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRLANG expression expression ) | STRDT OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRDT expression expression ) | SAMETERM OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( SAMETERM expression expression ) | ISIRI OPEN_BRACE expression CLOSE_BRACE -> ^( ISIRI expression ) | ISURI OPEN_BRACE expression CLOSE_BRACE -> ^( ISURI expression ) | ISBLANK OPEN_BRACE expression CLOSE_BRACE -> ^( ISBLANK expression ) | ISLITERAL OPEN_BRACE expression CLOSE_BRACE -> ^( ISLITERAL expression ) | ISNUMERIC OPEN_BRACE expression CLOSE_BRACE -> ^( ISNUMERIC expression ) | regexExpression -> regexExpression | existsFunction -> existsFunction | notExistsFunction -> notExistsFunction );
 18293  266
     public final SparqlParser.builtInCall_return builtInCall() throws RecognitionException {
 18294  532
         SparqlParser.builtInCall_return retval = new SparqlParser.builtInCall_return();
 18295  532
         retval.start = input.LT(1);
 18296  266
 
 18297  266
 
 18298  532
         Object root_0 = null;
 18299  266
 
 18300  532
         Token STR386=null;
 18301  532
         Token OPEN_BRACE387=null;
 18302  532
         Token CLOSE_BRACE389=null;
 18303  532
         Token LANG390=null;
 18304  532
         Token OPEN_BRACE391=null;
 18305  532
         Token CLOSE_BRACE393=null;
 18306  532
         Token LANGMATCHES394=null;
 18307  532
         Token OPEN_BRACE395=null;
 18308  532
         Token COMMA397=null;
 18309  532
         Token CLOSE_BRACE399=null;
 18310  532
         Token DATATYPE400=null;
 18311  532
         Token OPEN_BRACE401=null;
 18312  532
         Token CLOSE_BRACE403=null;
 18313  532
         Token BOUND404=null;
 18314  532
         Token OPEN_BRACE405=null;
 18315  532
         Token CLOSE_BRACE407=null;
 18316  532
         Token IRI408=null;
 18317  532
         Token OPEN_BRACE409=null;
 18318  532
         Token CLOSE_BRACE411=null;
 18319  532
         Token URI412=null;
 18320  532
         Token OPEN_BRACE413=null;
 18321  532
         Token CLOSE_BRACE415=null;
 18322  532
         Token BNODE416=null;
 18323  532
         Token OPEN_BRACE417=null;
 18324  532
         Token CLOSE_BRACE419=null;
 18325  532
         Token BNODE420=null;
 18326  532
         Token RAND422=null;
 18327  532
         Token ABS424=null;
 18328  532
         Token OPEN_BRACE425=null;
 18329  532
         Token CLOSE_BRACE427=null;
 18330  532
         Token CEIL428=null;
 18331  532
         Token OPEN_BRACE429=null;
 18332  532
         Token CLOSE_BRACE431=null;
 18333  532
         Token FLOOR432=null;
 18334  532
         Token OPEN_BRACE433=null;
 18335  532
         Token CLOSE_BRACE435=null;
 18336  532
         Token ROUND436=null;
 18337  532
         Token OPEN_BRACE437=null;
 18338  532
         Token CLOSE_BRACE439=null;
 18339  532
         Token CONCAT440=null;
 18340  532
         Token STRLEN443=null;
 18341  532
         Token OPEN_BRACE444=null;
 18342  532
         Token CLOSE_BRACE446=null;
 18343  532
         Token UCASE447=null;
 18344  532
         Token OPEN_BRACE448=null;
 18345  532
         Token CLOSE_BRACE450=null;
 18346  532
         Token LCASE451=null;
 18347  532
         Token OPEN_BRACE452=null;
 18348  532
         Token CLOSE_BRACE454=null;
 18349  532
         Token ENCODE_FOR_URI455=null;
 18350  532
         Token OPEN_BRACE456=null;
 18351  532
         Token CLOSE_BRACE458=null;
 18352  532
         Token CONTAINS459=null;
 18353  532
         Token OPEN_BRACE460=null;
 18354  532
         Token COMMA462=null;
 18355  532
         Token CLOSE_BRACE464=null;
 18356  532
         Token STRSTARTS465=null;
 18357  532
         Token OPEN_BRACE466=null;
 18358  532
         Token COMMA468=null;
 18359  532
         Token CLOSE_BRACE470=null;
 18360  532
         Token STRENDS471=null;
 18361  532
         Token OPEN_BRACE472=null;
 18362  532
         Token COMMA474=null;
 18363  532
         Token CLOSE_BRACE476=null;
 18364  532
         Token STRBEFORE477=null;
 18365  532
         Token OPEN_BRACE478=null;
 18366  532
         Token COMMA480=null;
 18367  532
         Token CLOSE_BRACE482=null;
 18368  532
         Token STRAFTER483=null;
 18369  532
         Token OPEN_BRACE484=null;
 18370  532
         Token COMMA486=null;
 18371  532
         Token CLOSE_BRACE488=null;
 18372  532
         Token REPLACE489=null;
 18373  532
         Token OPEN_BRACE490=null;
 18374  532
         Token COMMA492=null;
 18375  532
         Token COMMA494=null;
 18376  532
         Token CLOSE_BRACE496=null;
 18377  532
         Token YEAR497=null;
 18378  532
         Token OPEN_BRACE498=null;
 18379  532
         Token CLOSE_BRACE500=null;
 18380  532
         Token MONTH501=null;
 18381  532
         Token OPEN_BRACE502=null;
 18382  532
         Token CLOSE_BRACE504=null;
 18383  532
         Token DAY505=null;
 18384  532
         Token OPEN_BRACE506=null;
 18385  532
         Token CLOSE_BRACE508=null;
 18386  532
         Token HOURS509=null;
 18387  532
         Token OPEN_BRACE510=null;
 18388  532
         Token CLOSE_BRACE512=null;
 18389  532
         Token MINUTES513=null;
 18390  532
         Token OPEN_BRACE514=null;
 18391  532
         Token CLOSE_BRACE516=null;
 18392  532
         Token SECONDS517=null;
 18393  532
         Token OPEN_BRACE518=null;
 18394  532
         Token CLOSE_BRACE520=null;
 18395  532
         Token TIMEZONE521=null;
 18396  532
         Token OPEN_BRACE522=null;
 18397  532
         Token CLOSE_BRACE524=null;
 18398  532
         Token TZ525=null;
 18399  532
         Token OPEN_BRACE526=null;
 18400  532
         Token CLOSE_BRACE528=null;
 18401  532
         Token NOW529=null;
 18402  532
         Token MD5531=null;
 18403  532
         Token OPEN_BRACE532=null;
 18404  532
         Token CLOSE_BRACE534=null;
 18405  532
         Token SHA1535=null;
 18406  532
         Token OPEN_BRACE536=null;
 18407  532
         Token CLOSE_BRACE538=null;
 18408  532
         Token SHA224539=null;
 18409  532
         Token OPEN_BRACE540=null;
 18410  532
         Token CLOSE_BRACE542=null;
 18411  532
         Token SHA256543=null;
 18412  532
         Token OPEN_BRACE544=null;
 18413  532
         Token CLOSE_BRACE546=null;
 18414  532
         Token SHA384547=null;
 18415  532
         Token OPEN_BRACE548=null;
 18416  532
         Token CLOSE_BRACE550=null;
 18417  532
         Token SHA512551=null;
 18418  532
         Token OPEN_BRACE552=null;
 18419  532
         Token CLOSE_BRACE554=null;
 18420  532
         Token COALESCE555=null;
 18421  532
         Token IF557=null;
 18422  532
         Token OPEN_BRACE558=null;
 18423  532
         Token COMMA559=null;
 18424  532
         Token COMMA560=null;
 18425  532
         Token CLOSE_BRACE561=null;
 18426  532
         Token STRLANG562=null;
 18427  532
         Token OPEN_BRACE563=null;
 18428  532
         Token COMMA565=null;
 18429  532
         Token CLOSE_BRACE567=null;
 18430  532
         Token STRDT568=null;
 18431  266
         Token OPEN_BRACE569=null;
 18432  532
         Token COMMA571=null;
 18433  266
         Token CLOSE_BRACE573=null;
 18434  532
         Token SAMETERM574=null;
 18435  266
         Token OPEN_BRACE575=null;
 18436  532
         Token COMMA577=null;
 18437  266
         Token CLOSE_BRACE579=null;
 18438  532
         Token ISIRI580=null;
 18439  266
         Token OPEN_BRACE581=null;
 18440  532
         Token CLOSE_BRACE583=null;
 18441  266
         Token ISURI584=null;
 18442  532
         Token OPEN_BRACE585=null;
 18443  266
         Token CLOSE_BRACE587=null;
 18444  532
         Token ISBLANK588=null;
 18445  266
         Token OPEN_BRACE589=null;
 18446  532
         Token CLOSE_BRACE591=null;
 18447  266
         Token ISLITERAL592=null;
 18448  532
         Token OPEN_BRACE593=null;
 18449  266
         Token CLOSE_BRACE595=null;
 18450  532
         Token ISNUMERIC596=null;
 18451  266
         Token OPEN_BRACE597=null;
 18452  532
         Token CLOSE_BRACE599=null;
 18453  266
         SparqlParser.expression_return e1 =null;
 18454  266
 
 18455  266
         SparqlParser.expression_return e2 =null;
 18456  266
 
 18457  266
         SparqlParser.expression_return e3 =null;
 18458  266
 
 18459  266
         SparqlParser.expression_return expression388 =null;
 18460  266
 
 18461  266
         SparqlParser.expression_return expression392 =null;
 18462  266
 
 18463  266
         SparqlParser.expression_return expression396 =null;
 18464  266
 
 18465  266
         SparqlParser.expression_return expression398 =null;
 18466  266
 
 18467  266
         SparqlParser.expression_return expression402 =null;
 18468  266
 
 18469  266
         SparqlParser.var_return var406 =null;
 18470  266
 
 18471  266
         SparqlParser.expression_return expression410 =null;
 18472  266
 
 18473  266
         SparqlParser.expression_return expression414 =null;
 18474  266
 
 18475  266
         SparqlParser.expression_return expression418 =null;
 18476  266
 
 18477  266
         SparqlParser.nil_return nil421 =null;
 18478  266
 
 18479  266
         SparqlParser.nil_return nil423 =null;
 18480  266
 
 18481  266
         SparqlParser.expression_return expression426 =null;
 18482  266
 
 18483  266
         SparqlParser.expression_return expression430 =null;
 18484  266
 
 18485  266
         SparqlParser.expression_return expression434 =null;
 18486  266
 
 18487  266
         SparqlParser.expression_return expression438 =null;
 18488  266
 
 18489  266
         SparqlParser.expressionList_return expressionList441 =null;
 18490  266
 
 18491  266
         SparqlParser.subStringExpression_return subStringExpression442 =null;
 18492  266
 
 18493  266
         SparqlParser.expression_return expression445 =null;
 18494  266
 
 18495  266
         SparqlParser.expression_return expression449 =null;
 18496  266
 
 18497  266
         SparqlParser.expression_return expression453 =null;
 18498  266
 
 18499  266
         SparqlParser.expression_return expression457 =null;
 18500  266
 
 18501  266
         SparqlParser.expression_return expression461 =null;
 18502  266
 
 18503  266
         SparqlParser.expression_return expression463 =null;
 18504  266
 
 18505  266
         SparqlParser.expression_return expression467 =null;
 18506  266
 
 18507  266
         SparqlParser.expression_return expression469 =null;
 18508  266
 
 18509  266
         SparqlParser.expression_return expression473 =null;
 18510  266
 
 18511  266
         SparqlParser.expression_return expression475 =null;
 18512  266
 
 18513  266
         SparqlParser.expression_return expression479 =null;
 18514  266
 
 18515  266
         SparqlParser.expression_return expression481 =null;
 18516  266
 
 18517  266
         SparqlParser.expression_return expression485 =null;
 18518  266
 
 18519  266
         SparqlParser.expression_return expression487 =null;
 18520  266
 
 18521  266
         SparqlParser.expression_return expression491 =null;
 18522  266
 
 18523  266
         SparqlParser.expression_return expression493 =null;
 18524  266
 
 18525  266
         SparqlParser.expression_return expression495 =null;
 18526  266
 
 18527  266
         SparqlParser.expression_return expression499 =null;
 18528  266
 
 18529  266
         SparqlParser.expression_return expression503 =null;
 18530  266
 
 18531  266
         SparqlParser.expression_return expression507 =null;
 18532  266
 
 18533  266
         SparqlParser.expression_return expression511 =null;
 18534  266
 
 18535  266
         SparqlParser.expression_return expression515 =null;
 18536  266
 
 18537  266
         SparqlParser.expression_return expression519 =null;
 18538  266
 
 18539  266
         SparqlParser.expression_return expression523 =null;
 18540  266
 
 18541  266
         SparqlParser.expression_return expression527 =null;
 18542  266
 
 18543  266
         SparqlParser.nil_return nil530 =null;
 18544  266
 
 18545  266
         SparqlParser.expression_return expression533 =null;
 18546  266
 
 18547  266
         SparqlParser.expression_return expression537 =null;
 18548  266
 
 18549  266
         SparqlParser.expression_return expression541 =null;
 18550  266
 
 18551  266
         SparqlParser.expression_return expression545 =null;
 18552  266
 
 18553  266
         SparqlParser.expression_return expression549 =null;
 18554  266
 
 18555  266
         SparqlParser.expression_return expression553 =null;
 18556  266
 
 18557  266
         SparqlParser.expressionList_return expressionList556 =null;
 18558  266
 
 18559  266
         SparqlParser.expression_return expression564 =null;
 18560  266
 
 18561  266
         SparqlParser.expression_return expression566 =null;
 18562  266
 
 18563  266
         SparqlParser.expression_return expression570 =null;
 18564  
 
 18565  532
         SparqlParser.expression_return expression572 =null;
 18566  266
 
 18567  532
         SparqlParser.expression_return expression576 =null;
 18568  266
 
 18569  532
         SparqlParser.expression_return expression578 =null;
 18570  266
 
 18571  532
         SparqlParser.expression_return expression582 =null;
 18572  266
 
 18573  532
         SparqlParser.expression_return expression586 =null;
 18574  266
 
 18575  532
         SparqlParser.expression_return expression590 =null;
 18576  266
 
 18577  532
         SparqlParser.expression_return expression594 =null;
 18578  266
 
 18579  532
         SparqlParser.expression_return expression598 =null;
 18580  266
 
 18581  532
         SparqlParser.regexExpression_return regexExpression600 =null;
 18582  266
 
 18583  532
         SparqlParser.existsFunction_return existsFunction601 =null;
 18584  266
 
 18585  532
         SparqlParser.notExistsFunction_return notExistsFunction602 =null;
 18586  266
 
 18587  266
 
 18588  532
         Object STR386_tree=null;
 18589  532
         Object OPEN_BRACE387_tree=null;
 18590  532
         Object CLOSE_BRACE389_tree=null;
 18591  532
         Object LANG390_tree=null;
 18592  532
         Object OPEN_BRACE391_tree=null;
 18593  532
         Object CLOSE_BRACE393_tree=null;
 18594  532
         Object LANGMATCHES394_tree=null;
 18595  532
         Object OPEN_BRACE395_tree=null;
 18596  532
         Object COMMA397_tree=null;
 18597  532
         Object CLOSE_BRACE399_tree=null;
 18598  532
         Object DATATYPE400_tree=null;
 18599  532
         Object OPEN_BRACE401_tree=null;
 18600  532
         Object CLOSE_BRACE403_tree=null;
 18601  532
         Object BOUND404_tree=null;
 18602  532
         Object OPEN_BRACE405_tree=null;
 18603  532
         Object CLOSE_BRACE407_tree=null;
 18604  532
         Object IRI408_tree=null;
 18605  532
         Object OPEN_BRACE409_tree=null;
 18606  532
         Object CLOSE_BRACE411_tree=null;
 18607  532
         Object URI412_tree=null;
 18608  532
         Object OPEN_BRACE413_tree=null;
 18609  532
         Object CLOSE_BRACE415_tree=null;
 18610  532
         Object BNODE416_tree=null;
 18611  532
         Object OPEN_BRACE417_tree=null;
 18612  532
         Object CLOSE_BRACE419_tree=null;
 18613  532
         Object BNODE420_tree=null;
 18614  532
         Object RAND422_tree=null;
 18615  532
         Object ABS424_tree=null;
 18616  532
         Object OPEN_BRACE425_tree=null;
 18617  532
         Object CLOSE_BRACE427_tree=null;
 18618  532
         Object CEIL428_tree=null;
 18619  532
         Object OPEN_BRACE429_tree=null;
 18620  532
         Object CLOSE_BRACE431_tree=null;
 18621  532
         Object FLOOR432_tree=null;
 18622  532
         Object OPEN_BRACE433_tree=null;
 18623  532
         Object CLOSE_BRACE435_tree=null;
 18624  532
         Object ROUND436_tree=null;
 18625  532
         Object OPEN_BRACE437_tree=null;
 18626  532
         Object CLOSE_BRACE439_tree=null;
 18627  532
         Object CONCAT440_tree=null;
 18628  532
         Object STRLEN443_tree=null;
 18629  532
         Object OPEN_BRACE444_tree=null;
 18630  532
         Object CLOSE_BRACE446_tree=null;
 18631  532
         Object UCASE447_tree=null;
 18632  532
         Object OPEN_BRACE448_tree=null;
 18633  532
         Object CLOSE_BRACE450_tree=null;
 18634  532
         Object LCASE451_tree=null;
 18635  532
         Object OPEN_BRACE452_tree=null;
 18636  532
         Object CLOSE_BRACE454_tree=null;
 18637  532
         Object ENCODE_FOR_URI455_tree=null;
 18638  532
         Object OPEN_BRACE456_tree=null;
 18639  532
         Object CLOSE_BRACE458_tree=null;
 18640  532
         Object CONTAINS459_tree=null;
 18641  532
         Object OPEN_BRACE460_tree=null;
 18642  532
         Object COMMA462_tree=null;
 18643  532
         Object CLOSE_BRACE464_tree=null;
 18644  532
         Object STRSTARTS465_tree=null;
 18645  532
         Object OPEN_BRACE466_tree=null;
 18646  532
         Object COMMA468_tree=null;
 18647  532
         Object CLOSE_BRACE470_tree=null;
 18648  532
         Object STRENDS471_tree=null;
 18649  532
         Object OPEN_BRACE472_tree=null;
 18650  532
         Object COMMA474_tree=null;
 18651  532
         Object CLOSE_BRACE476_tree=null;
 18652  532
         Object STRBEFORE477_tree=null;
 18653  532
         Object OPEN_BRACE478_tree=null;
 18654  532
         Object COMMA480_tree=null;
 18655  532
         Object CLOSE_BRACE482_tree=null;
 18656  532
         Object STRAFTER483_tree=null;
 18657  532
         Object OPEN_BRACE484_tree=null;
 18658  532
         Object COMMA486_tree=null;
 18659  532
         Object CLOSE_BRACE488_tree=null;
 18660  532
         Object REPLACE489_tree=null;
 18661  532
         Object OPEN_BRACE490_tree=null;
 18662  532
         Object COMMA492_tree=null;
 18663  532
         Object COMMA494_tree=null;
 18664  532
         Object CLOSE_BRACE496_tree=null;
 18665  532
         Object YEAR497_tree=null;
 18666  532
         Object OPEN_BRACE498_tree=null;
 18667  532
         Object CLOSE_BRACE500_tree=null;
 18668  532
         Object MONTH501_tree=null;
 18669  532
         Object OPEN_BRACE502_tree=null;
 18670  532
         Object CLOSE_BRACE504_tree=null;
 18671  532
         Object DAY505_tree=null;
 18672  532
         Object OPEN_BRACE506_tree=null;
 18673  532
         Object CLOSE_BRACE508_tree=null;
 18674  532
         Object HOURS509_tree=null;
 18675  532
         Object OPEN_BRACE510_tree=null;
 18676  532
         Object CLOSE_BRACE512_tree=null;
 18677  532
         Object MINUTES513_tree=null;
 18678  532
         Object OPEN_BRACE514_tree=null;
 18679  532
         Object CLOSE_BRACE516_tree=null;
 18680  532
         Object SECONDS517_tree=null;
 18681  532
         Object OPEN_BRACE518_tree=null;
 18682  532
         Object CLOSE_BRACE520_tree=null;
 18683  532
         Object TIMEZONE521_tree=null;
 18684  532
         Object OPEN_BRACE522_tree=null;
 18685  532
         Object CLOSE_BRACE524_tree=null;
 18686  532
         Object TZ525_tree=null;
 18687  532
         Object OPEN_BRACE526_tree=null;
 18688  532
         Object CLOSE_BRACE528_tree=null;
 18689  532
         Object NOW529_tree=null;
 18690  532
         Object MD5531_tree=null;
 18691  532
         Object OPEN_BRACE532_tree=null;
 18692  532
         Object CLOSE_BRACE534_tree=null;
 18693  532
         Object SHA1535_tree=null;
 18694  532
         Object OPEN_BRACE536_tree=null;
 18695  532
         Object CLOSE_BRACE538_tree=null;
 18696  532
         Object SHA224539_tree=null;
 18697  532
         Object OPEN_BRACE540_tree=null;
 18698  532
         Object CLOSE_BRACE542_tree=null;
 18699  532
         Object SHA256543_tree=null;
 18700  532
         Object OPEN_BRACE544_tree=null;
 18701  532
         Object CLOSE_BRACE546_tree=null;
 18702  532
         Object SHA384547_tree=null;
 18703  532
         Object OPEN_BRACE548_tree=null;
 18704  532
         Object CLOSE_BRACE550_tree=null;
 18705  532
         Object SHA512551_tree=null;
 18706  532
         Object OPEN_BRACE552_tree=null;
 18707  532
         Object CLOSE_BRACE554_tree=null;
 18708  532
         Object COALESCE555_tree=null;
 18709  532
         Object IF557_tree=null;
 18710  532
         Object OPEN_BRACE558_tree=null;
 18711  532
         Object COMMA559_tree=null;
 18712  532
         Object COMMA560_tree=null;
 18713  532
         Object CLOSE_BRACE561_tree=null;
 18714  532
         Object STRLANG562_tree=null;
 18715  532
         Object OPEN_BRACE563_tree=null;
 18716  532
         Object COMMA565_tree=null;
 18717  532
         Object CLOSE_BRACE567_tree=null;
 18718  532
         Object STRDT568_tree=null;
 18719  532
         Object OPEN_BRACE569_tree=null;
 18720  532
         Object COMMA571_tree=null;
 18721  532
         Object CLOSE_BRACE573_tree=null;
 18722  532
         Object SAMETERM574_tree=null;
 18723  532
         Object OPEN_BRACE575_tree=null;
 18724  532
         Object COMMA577_tree=null;
 18725  532
         Object CLOSE_BRACE579_tree=null;
 18726  532
         Object ISIRI580_tree=null;
 18727  532
         Object OPEN_BRACE581_tree=null;
 18728  532
         Object CLOSE_BRACE583_tree=null;
 18729  532
         Object ISURI584_tree=null;
 18730  532
         Object OPEN_BRACE585_tree=null;
 18731  532
         Object CLOSE_BRACE587_tree=null;
 18732  532
         Object ISBLANK588_tree=null;
 18733  532
         Object OPEN_BRACE589_tree=null;
 18734  532
         Object CLOSE_BRACE591_tree=null;
 18735  532
         Object ISLITERAL592_tree=null;
 18736  532
         Object OPEN_BRACE593_tree=null;
 18737  532
         Object CLOSE_BRACE595_tree=null;
 18738  532
         Object ISNUMERIC596_tree=null;
 18739  532
         Object OPEN_BRACE597_tree=null;
 18740  532
         Object CLOSE_BRACE599_tree=null;
 18741  532
         RewriteRuleTokenStream stream_SHA256=new RewriteRuleTokenStream(adaptor,"token SHA256");
 18742  532
         RewriteRuleTokenStream stream_YEAR=new RewriteRuleTokenStream(adaptor,"token YEAR");
 18743  532
         RewriteRuleTokenStream stream_TIMEZONE=new RewriteRuleTokenStream(adaptor,"token TIMEZONE");
 18744  532
         RewriteRuleTokenStream stream_CONTAINS=new RewriteRuleTokenStream(adaptor,"token CONTAINS");
 18745  532
         RewriteRuleTokenStream stream_STRENDS=new RewriteRuleTokenStream(adaptor,"token STRENDS");
 18746  532
         RewriteRuleTokenStream stream_LCASE=new RewriteRuleTokenStream(adaptor,"token LCASE");
 18747  532
         RewriteRuleTokenStream stream_BNODE=new RewriteRuleTokenStream(adaptor,"token BNODE");
 18748  532
         RewriteRuleTokenStream stream_SHA512=new RewriteRuleTokenStream(adaptor,"token SHA512");
 18749  532
         RewriteRuleTokenStream stream_SECONDS=new RewriteRuleTokenStream(adaptor,"token SECONDS");
 18750  532
         RewriteRuleTokenStream stream_NOW=new RewriteRuleTokenStream(adaptor,"token NOW");
 18751  532
         RewriteRuleTokenStream stream_DAY=new RewriteRuleTokenStream(adaptor,"token DAY");
 18752  532
         RewriteRuleTokenStream stream_SHA224=new RewriteRuleTokenStream(adaptor,"token SHA224");
 18753  532
         RewriteRuleTokenStream stream_STRAFTER=new RewriteRuleTokenStream(adaptor,"token STRAFTER");
 18754  532
         RewriteRuleTokenStream stream_STRLEN=new RewriteRuleTokenStream(adaptor,"token STRLEN");
 18755  532
         RewriteRuleTokenStream stream_MONTH=new RewriteRuleTokenStream(adaptor,"token MONTH");
 18756  532
         RewriteRuleTokenStream stream_ENCODE_FOR_URI=new RewriteRuleTokenStream(adaptor,"token ENCODE_FOR_URI");
 18757  532
         RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
 18758  532
         RewriteRuleTokenStream stream_ISURI=new RewriteRuleTokenStream(adaptor,"token ISURI");
 18759  532
         RewriteRuleTokenStream stream_STR=new RewriteRuleTokenStream(adaptor,"token STR");
 18760  532
         RewriteRuleTokenStream stream_ISLITERAL=new RewriteRuleTokenStream(adaptor,"token ISLITERAL");
 18761  532
         RewriteRuleTokenStream stream_STRDT=new RewriteRuleTokenStream(adaptor,"token STRDT");
 18762  532
         RewriteRuleTokenStream stream_SAMETERM=new RewriteRuleTokenStream(adaptor,"token SAMETERM");
 18763  532
         RewriteRuleTokenStream stream_MD5=new RewriteRuleTokenStream(adaptor,"token MD5");
 18764  532
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 18765  532
         RewriteRuleTokenStream stream_RAND=new RewriteRuleTokenStream(adaptor,"token RAND");
 18766  532
         RewriteRuleTokenStream stream_REPLACE=new RewriteRuleTokenStream(adaptor,"token REPLACE");
 18767  532
         RewriteRuleTokenStream stream_IRI=new RewriteRuleTokenStream(adaptor,"token IRI");
 18768  532
         RewriteRuleTokenStream stream_LANGMATCHES=new RewriteRuleTokenStream(adaptor,"token LANGMATCHES");
 18769  532
         RewriteRuleTokenStream stream_TZ=new RewriteRuleTokenStream(adaptor,"token TZ");
 18770  532
         RewriteRuleTokenStream stream_STRLANG=new RewriteRuleTokenStream(adaptor,"token STRLANG");
 18771  532
         RewriteRuleTokenStream stream_BOUND=new RewriteRuleTokenStream(adaptor,"token BOUND");
 18772  532
         RewriteRuleTokenStream stream_ISIRI=new RewriteRuleTokenStream(adaptor,"token ISIRI");
 18773  532
         RewriteRuleTokenStream stream_COALESCE=new RewriteRuleTokenStream(adaptor,"token COALESCE");
 18774  532
         RewriteRuleTokenStream stream_ISNUMERIC=new RewriteRuleTokenStream(adaptor,"token ISNUMERIC");
 18775  532
         RewriteRuleTokenStream stream_CONCAT=new RewriteRuleTokenStream(adaptor,"token CONCAT");
 18776  532
         RewriteRuleTokenStream stream_STRSTARTS=new RewriteRuleTokenStream(adaptor,"token STRSTARTS");
 18777  532
         RewriteRuleTokenStream stream_STRBEFORE=new RewriteRuleTokenStream(adaptor,"token STRBEFORE");
 18778  266
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 18779  266
         RewriteRuleTokenStream stream_SHA1=new RewriteRuleTokenStream(adaptor,"token SHA1");
 18780  532
         RewriteRuleTokenStream stream_FLOOR=new RewriteRuleTokenStream(adaptor,"token FLOOR");
 18781  532
         RewriteRuleTokenStream stream_ISBLANK=new RewriteRuleTokenStream(adaptor,"token ISBLANK");
 18782  266
         RewriteRuleTokenStream stream_UCASE=new RewriteRuleTokenStream(adaptor,"token UCASE");
 18783  266
         RewriteRuleTokenStream stream_URI=new RewriteRuleTokenStream(adaptor,"token URI");
 18784  284
         RewriteRuleTokenStream stream_ABS=new RewriteRuleTokenStream(adaptor,"token ABS");
 18785  266
         RewriteRuleTokenStream stream_MINUTES=new RewriteRuleTokenStream(adaptor,"token MINUTES");
 18786  284
         RewriteRuleTokenStream stream_ROUND=new RewriteRuleTokenStream(adaptor,"token ROUND");
 18787  266
         RewriteRuleTokenStream stream_CEIL=new RewriteRuleTokenStream(adaptor,"token CEIL");
 18788  266
         RewriteRuleTokenStream stream_DATATYPE=new RewriteRuleTokenStream(adaptor,"token DATATYPE");
 18789  286
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 18790  266
         RewriteRuleTokenStream stream_SHA384=new RewriteRuleTokenStream(adaptor,"token SHA384");
 18791  286
         RewriteRuleTokenStream stream_HOURS=new RewriteRuleTokenStream(adaptor,"token HOURS");
 18792  266
         RewriteRuleTokenStream stream_LANG=new RewriteRuleTokenStream(adaptor,"token LANG");
 18793  266
         RewriteRuleSubtreeStream stream_existsFunction=new RewriteRuleSubtreeStream(adaptor,"rule existsFunction");
 18794  281
         RewriteRuleSubtreeStream stream_subStringExpression=new RewriteRuleSubtreeStream(adaptor,"rule subStringExpression");
 18795  266
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 18796  281
         RewriteRuleSubtreeStream stream_notExistsFunction=new RewriteRuleSubtreeStream(adaptor,"rule notExistsFunction");
 18797  266
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 18798  266
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 18799  316
         RewriteRuleSubtreeStream stream_regexExpression=new RewriteRuleSubtreeStream(adaptor,"rule regexExpression");
 18800  266
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 18801  50
         try {
 18802  
             // com\\googlecode\\sparkleg\\Sparql.g:540:5: ( STR OPEN_BRACE expression CLOSE_BRACE -> ^( STR expression ) | LANG OPEN_BRACE expression CLOSE_BRACE -> ^( LANG expression ) | LANGMATCHES OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( LANGMATCHES ( expression )+ ) | DATATYPE OPEN_BRACE expression CLOSE_BRACE -> ^( DATATYPE expression ) | BOUND OPEN_BRACE var CLOSE_BRACE -> ^( BOUND var ) | IRI OPEN_BRACE expression CLOSE_BRACE -> ^( IRI expression ) | URI OPEN_BRACE expression CLOSE_BRACE -> ^( URI expression ) | BNODE ( OPEN_BRACE expression CLOSE_BRACE ) -> ^( BNODE expression ) | BNODE nil -> BNODE | RAND nil -> RAND | ABS OPEN_BRACE expression CLOSE_BRACE -> ^( ABS expression ) | CEIL OPEN_BRACE expression CLOSE_BRACE -> ^( CEIL expression ) | FLOOR OPEN_BRACE expression CLOSE_BRACE -> ^( FLOOR expression ) | ROUND OPEN_BRACE expression CLOSE_BRACE -> ^( ROUND expression ) | CONCAT expressionList -> ^( CONCAT expressionList ) | subStringExpression -> subStringExpression | STRLEN OPEN_BRACE expression CLOSE_BRACE -> ^( STRLEN expression ) | UCASE OPEN_BRACE expression CLOSE_BRACE -> ^( UCASE expression ) | LCASE OPEN_BRACE expression CLOSE_BRACE -> ^( LCASE expression ) | ENCODE_FOR_URI OPEN_BRACE expression CLOSE_BRACE -> ^( ENCODE_FOR_URI expression ) | CONTAINS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( CONTAINS expression expression ) | STRSTARTS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRSTARTS expression expression ) | STRENDS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRENDS expression expression ) | STRBEFORE OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRBEFORE expression expression ) | STRAFTER OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRAFTER expression expression ) | REPLACE OPEN_BRACE expression COMMA expression COMMA expression CLOSE_BRACE -> ^( REPLACE expression expression expression ) | YEAR OPEN_BRACE expression CLOSE_BRACE -> ^( YEAR expression ) | MONTH OPEN_BRACE expression CLOSE_BRACE -> ^( MONTH expression ) | DAY OPEN_BRACE expression CLOSE_BRACE -> ^( DAY expression ) | HOURS OPEN_BRACE expression CLOSE_BRACE -> ^( HOURS expression ) | MINUTES OPEN_BRACE expression CLOSE_BRACE -> ^( MINUTES expression ) | SECONDS OPEN_BRACE expression CLOSE_BRACE -> ^( SECONDS expression ) | TIMEZONE OPEN_BRACE expression CLOSE_BRACE -> ^( TIMEZONE expression ) | TZ OPEN_BRACE expression CLOSE_BRACE -> ^( TZ expression ) | NOW nil -> NOW | MD5 OPEN_BRACE expression CLOSE_BRACE -> ^( MD5 expression ) | SHA1 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA1 expression ) | SHA224 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA224 expression ) | SHA256 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA256 expression ) | SHA384 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA384 expression ) | SHA512 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA512 expression ) | COALESCE expressionList -> ^( COALESCE expressionList ) | IF OPEN_BRACE e1= expression COMMA e2= expression COMMA e3= expression CLOSE_BRACE -> ^( IF $e1 $e2 $e3) | STRLANG OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRLANG expression expression ) | STRDT OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRDT expression expression ) | SAMETERM OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( SAMETERM expression expression ) | ISIRI OPEN_BRACE expression CLOSE_BRACE -> ^( ISIRI expression ) | ISURI OPEN_BRACE expression CLOSE_BRACE -> ^( ISURI expression ) | ISBLANK OPEN_BRACE expression CLOSE_BRACE -> ^( ISBLANK expression ) | ISLITERAL OPEN_BRACE expression CLOSE_BRACE -> ^( ISLITERAL expression ) | ISNUMERIC OPEN_BRACE expression CLOSE_BRACE -> ^( ISNUMERIC expression ) | regexExpression -> regexExpression | existsFunction -> existsFunction | notExistsFunction -> notExistsFunction )
 18803  266
             int alt126=54;
 18804  281
             switch ( input.LA(1) ) {
 18805  
             case STR:
 18806  15
                 {
 18807  18
                 alt126=1;
 18808  
                 }
 18809  19
                 break;
 18810  
             case LANG:
 18811  1
                 {
 18812  20
                 alt126=2;
 18813  
                 }
 18814  21
                 break;
 18815  
             case LANGMATCHES:
 18816  1
                 {
 18817  15
                 alt126=3;
 18818  
                 }
 18819  19
                 break;
 18820  
             case DATATYPE:
 18821  
                 {
 18822  54
                 alt126=4;
 18823  
                 }
 18824  50
                 break;
 18825  2
             case BOUND:
 18826  
                 {
 18827  17
                 alt126=5;
 18828  
                 }
 18829  15
                 break;
 18830  
             case IRI:
 18831  
                 {
 18832  1
                 alt126=6;
 18833  
                 }
 18834  1
                 break;
 18835  
             case URI:
 18836  
                 {
 18837  1
                 alt126=7;
 18838  
                 }
 18839  1
                 break;
 18840  
             case BNODE:
 18841  
                 {
 18842  4
                 switch ( input.LA(2) ) {
 18843  
                 case OPEN_BRACE:
 18844  
                     {
 18845  4
                     switch ( input.LA(3) ) {
 18846  
                     case CLOSE_BRACE:
 18847  
                         {
 18848  2
                         alt126=9;
 18849  
                         }
 18850  2
                         break;
 18851  
                     case ABS:
 18852  
                     case AVG:
 18853  
                     case BNODE:
 18854  
                     case BOUND:
 18855  
                     case CEIL:
 18856  
                     case COALESCE:
 18857  
                     case CONCAT:
 18858  
                     case CONTAINS:
 18859  
                     case COUNT:
 18860  
                     case DATATYPE:
 18861  
                     case DAY:
 18862  
                     case DECIMAL:
 18863  
                     case DECIMAL_NEGATIVE:
 18864  
                     case DECIMAL_POSITIVE:
 18865  
                     case DOUBLE:
 18866  
                     case DOUBLE_NEGATIVE:
 18867  
                     case DOUBLE_POSITIVE:
 18868  
                     case ENCODE_FOR_URI:
 18869  
                     case EXISTS:
 18870  
                     case FALSE:
 18871  
                     case FLOOR:
 18872  
                     case GROUP_CONCAT:
 18873  
                     case HOURS:
 18874  
                     case IF:
 18875  
                     case INTEGER:
 18876  
                     case INTEGER_NEGATIVE:
 18877  
                     case INTEGER_POSITIVE:
 18878  
                     case IRI:
 18879  
                     case IRI_REF:
 18880  
                     case ISBLANK:
 18881  
                     case ISIRI:
 18882  
                     case ISLITERAL:
 18883  
                     case ISNUMERIC:
 18884  
                     case ISURI:
 18885  
                     case LANG:
 18886  
                     case LANGMATCHES:
 18887  
                     case LCASE:
 18888  
                     case MAX:
 18889  
                     case MD5:
 18890  
                     case MIN:
 18891  
                     case MINUS:
 18892  
                     case MINUTES:
 18893  
                     case MONTH:
 18894  
                     case NEGATION:
 18895  
                     case NOT:
 18896  
                     case NOW:
 18897  
                     case OPEN_BRACE:
 18898  
                     case PLUS:
 18899  
                     case PNAME_LN:
 18900  
                     case PNAME_NS:
 18901  
                     case RAND:
 18902  
                     case REGEX:
 18903  
                     case REPLACE:
 18904  
                     case ROUND:
 18905  
                     case SAMETERM:
 18906  
                     case SAMPLE:
 18907  
                     case SECONDS:
 18908  
                     case SHA1:
 18909  
                     case SHA224:
 18910  
                     case SHA256:
 18911  
                     case SHA384:
 18912  
                     case SHA512:
 18913  2
                     case STR:
 18914  
                     case STRAFTER:
 18915  2
                     case STRBEFORE:
 18916  
                     case STRDT:
 18917  
                     case STRENDS:
 18918  
                     case STRING_LITERAL1:
 18919  
                     case STRING_LITERAL2:
 18920  
                     case STRING_LITERAL_LONG1:
 18921  
                     case STRING_LITERAL_LONG2:
 18922  
                     case STRLANG:
 18923  
                     case STRLEN:
 18924  
                     case STRSTARTS:
 18925  4
                     case SUBSTR:
 18926  
                     case SUM:
 18927  
                     case TIMEZONE:
 18928  
                     case TRUE:
 18929  
                     case TZ:
 18930  
                     case UCASE:
 18931  
                     case URI:
 18932  
                     case VAR1:
 18933  
                     case VAR2:
 18934  
                     case YEAR:
 18935  4
                         {
 18936  2
                         alt126=8;
 18937  
                         }
 18938  3
                         break;
 18939  
                     default:
 18940  1
                         NoViableAltException nvae =
 18941  
                             new NoViableAltException("", 126, 54, input);
 18942  
 
 18943  1
                         throw nvae;
 18944  
 
 18945  1
                     }
 18946  
 
 18947  
                     }
 18948  5
                     break;
 18949  
                 default:
 18950  1
                     NoViableAltException nvae =
 18951  
                         new NoViableAltException("", 126, 8, input);
 18952  
 
 18953  1
                     throw nvae;
 18954  
 
 18955  1
                 }
 18956  
 
 18957  
                 }
 18958  5
                 break;
 18959  
             case RAND:
 18960  1
                 {
 18961  1
                 alt126=10;
 18962  
                 }
 18963  6
                 break;
 18964  
             case ABS:
 18965  5
                 {
 18966  1
                 alt126=11;
 18967  
                 }
 18968  3
                 break;
 18969  
             case CEIL:
 18970  2
                 {
 18971  1
                 alt126=12;
 18972  
                 }
 18973  2
                 break;
 18974  
             case FLOOR:
 18975  1
                 {
 18976  1
                 alt126=13;
 18977  
                 }
 18978  2
                 break;
 18979  
             case ROUND:
 18980  1
                 {
 18981  1
                 alt126=14;
 18982  
                 }
 18983  2
                 break;
 18984  
             case CONCAT:
 18985  1
                 {
 18986  5
                 alt126=15;
 18987  
                 }
 18988  6
                 break;
 18989  
             case SUBSTR:
 18990  1
                 {
 18991  2
                 alt126=16;
 18992  
                 }
 18993  3
                 break;
 18994  
             case STRLEN:
 18995  1
                 {
 18996  1
                 alt126=17;
 18997  
                 }
 18998  2
                 break;
 18999  
             case UCASE:
 19000  1
                 {
 19001  1
                 alt126=18;
 19002  
                 }
 19003  2
                 break;
 19004  
             case LCASE:
 19005  1
                 {
 19006  1
                 alt126=19;
 19007  
                 }
 19008  2
                 break;
 19009  
             case ENCODE_FOR_URI:
 19010  1
                 {
 19011  1
                 alt126=20;
 19012  
                 }
 19013  2
                 break;
 19014  
             case CONTAINS:
 19015  1
                 {
 19016  1
                 alt126=21;
 19017  
                 }
 19018  4
                 break;
 19019  
             case STRSTARTS:
 19020  3
                 {
 19021  1
                 alt126=22;
 19022  
                 }
 19023  2
                 break;
 19024  
             case STRENDS:
 19025  1
                 {
 19026  1
                 alt126=23;
 19027  
                 }
 19028  2
                 break;
 19029  
             case STRBEFORE:
 19030  1
                 {
 19031  1
                 alt126=24;
 19032  
                 }
 19033  2
                 break;
 19034  
             case STRAFTER:
 19035  1
                 {
 19036  1
                 alt126=25;
 19037  
                 }
 19038  2
                 break;
 19039  
             case REPLACE:
 19040  1
                 {
 19041  3
                 alt126=26;
 19042  
                 }
 19043  4
                 break;
 19044  
             case YEAR:
 19045  1
                 {
 19046  1
                 alt126=27;
 19047  
                 }
 19048  2
                 break;
 19049  
             case MONTH:
 19050  1
                 {
 19051  1
                 alt126=28;
 19052  
                 }
 19053  2
                 break;
 19054  
             case DAY:
 19055  1
                 {
 19056  1
                 alt126=29;
 19057  
                 }
 19058  2
                 break;
 19059  
             case HOURS:
 19060  1
                 {
 19061  1
                 alt126=30;
 19062  
                 }
 19063  2
                 break;
 19064  
             case MINUTES:
 19065  1
                 {
 19066  1
                 alt126=31;
 19067  
                 }
 19068  3
                 break;
 19069  
             case SECONDS:
 19070  2
                 {
 19071  1
                 alt126=32;
 19072  
                 }
 19073  3
                 break;
 19074  
             case TIMEZONE:
 19075  2
                 {
 19076  1
                 alt126=33;
 19077  
                 }
 19078  1
                 break;
 19079  
             case TZ:
 19080  
                 {
 19081  1
                 alt126=34;
 19082  
                 }
 19083  3
                 break;
 19084  
             case NOW:
 19085  2
                 {
 19086  1
                 alt126=35;
 19087  
                 }
 19088  3
                 break;
 19089  
             case MD5:
 19090  2
                 {
 19091  2
                 alt126=36;
 19092  
                 }
 19093  4
                 break;
 19094  
             case SHA1:
 19095  2
                 {
 19096  2
                 alt126=37;
 19097  
                 }
 19098  8
                 break;
 19099  
             case SHA224:
 19100  6
                 {
 19101  0
                 alt126=38;
 19102  
                 }
 19103  3
                 break;
 19104  
             case SHA256:
 19105  3
                 {
 19106  2
                 alt126=39;
 19107  
                 }
 19108  5
                 break;
 19109  
             case SHA384:
 19110  3
                 {
 19111  2
                 alt126=40;
 19112  
                 }
 19113  5
                 break;
 19114  
             case SHA512:
 19115  3
                 {
 19116  2
                 alt126=41;
 19117  
                 }
 19118  17
                 break;
 19119  
             case COALESCE:
 19120  15
                 {
 19121  6
                 alt126=42;
 19122  
                 }
 19123  10
                 break;
 19124  
             case IF:
 19125  4
                 {
 19126  3
                 alt126=43;
 19127  
                 }
 19128  4
                 break;
 19129  
             case STRLANG:
 19130  1
                 {
 19131  3
                 alt126=44;
 19132  
                 }
 19133  7
                 break;
 19134  
             case STRDT:
 19135  4
                 {
 19136  3
                 alt126=45;
 19137  
                 }
 19138  7
                 break;
 19139  
             case SAMETERM:
 19140  4
                 {
 19141  15
                 alt126=46;
 19142  
                 }
 19143  17
                 break;
 19144  
             case ISIRI:
 19145  2
                 {
 19146  4
                 alt126=47;
 19147  
                 }
 19148  25
                 break;
 19149  
             case ISURI:
 19150  21
                 {
 19151  1
                 alt126=48;
 19152  
                 }
 19153  11
                 break;
 19154  
             case ISBLANK:
 19155  10
                 {
 19156  4
                 alt126=49;
 19157  
                 }
 19158  27
                 break;
 19159  
             case ISLITERAL:
 19160  23
                 {
 19161  4
                 alt126=50;
 19162  
                 }
 19163  4
                 break;
 19164  
             case ISNUMERIC:
 19165  
                 {
 19166  2
                 alt126=51;
 19167  
                 }
 19168  2
                 break;
 19169  266
             case REGEX:
 19170  
                 {
 19171  21
                 alt126=52;
 19172  
                 }
 19173  39
                 break;
 19174  18
             case EXISTS:
 19175  
                 {
 19176  10
                 alt126=53;
 19177  18
                 }
 19178  28
                 break;
 19179  
             case NOT:
 19180  
                 {
 19181  41
                 alt126=54;
 19182  18
                 }
 19183  23
                 break;
 19184  18
             default:
 19185  0
                 NoViableAltException nvae =
 19186  18
                     new NoViableAltException("", 126, 0, input);
 19187  
 
 19188  18
                 throw nvae;
 19189  18
 
 19190  
             }
 19191  
 
 19192  266
             switch (alt126) {
 19193  
                 case 1 :
 19194  
                     // com\\googlecode\\sparkleg\\Sparql.g:540:7: STR OPEN_BRACE expression CLOSE_BRACE
 19195  
                     {
 19196  18
                     STR386=(Token)match(input,STR,FOLLOW_STR_in_builtInCall5008);  
 19197  18
                     stream_STR.add(STR386);
 19198  
 
 19199  18
 
 19200  36
                     OPEN_BRACE387=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5010);  
 19201  18
                     stream_OPEN_BRACE.add(OPEN_BRACE387);
 19202  18
 
 19203  
 
 19204  18
                     pushFollow(FOLLOW_expression_in_builtInCall5012);
 19205  18
                     expression388=expression();
 19206  
 
 19207  36
                     state._fsp--;
 19208  18
 
 19209  18
                     stream_expression.add(expression388.getTree());
 19210  
 
 19211  18
                     CLOSE_BRACE389=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5014);  
 19212  36
                     stream_CLOSE_BRACE.add(CLOSE_BRACE389);
 19213  
 
 19214  18
 
 19215  
                     // AST REWRITE
 19216  
                     // elements: STR, expression
 19217  
                     // token labels: 
 19218  
                     // rule labels: retval
 19219  
                     // token list labels: 
 19220  18
                     // rule list labels: 
 19221  
                     // wildcard labels: 
 19222  18
                     retval.tree = root_0;
 19223  36
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19224  
 
 19225  18
                     root_0 = (Object)adaptor.nil();
 19226  
                     // 540:45: -> ^( STR expression )
 19227  20
                     {
 19228  20
                         // com\\googlecode\\sparkleg\\Sparql.g:540:48: ^( STR expression )
 19229  
                         {
 19230  18
                         Object root_1 = (Object)adaptor.nil();
 19231  38
                         root_1 = (Object)adaptor.becomeRoot(
 19232  20
                         stream_STR.nextNode()
 19233  
                         , root_1);
 19234  
 
 19235  38
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19236  20
 
 19237  18
                         adaptor.addChild(root_0, root_1);
 19238  20
                         }
 19239  
 
 19240  20
                     }
 19241  
 
 19242  20
 
 19243  38
                     retval.tree = root_0;
 19244  
 
 19245  
                     }
 19246  18
                     break;
 19247  
                 case 2 :
 19248  
                     // com\\googlecode\\sparkleg\\Sparql.g:541:7: LANG OPEN_BRACE expression CLOSE_BRACE
 19249  
                     {
 19250  20
                     LANG390=(Token)match(input,LANG,FOLLOW_LANG_in_builtInCall5030);  
 19251  20
                     stream_LANG.add(LANG390);
 19252  
 
 19253  20
 
 19254  40
                     OPEN_BRACE391=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5032);  
 19255  20
                     stream_OPEN_BRACE.add(OPEN_BRACE391);
 19256  20
 
 19257  
 
 19258  20
                     pushFollow(FOLLOW_expression_in_builtInCall5034);
 19259  20
                     expression392=expression();
 19260  
 
 19261  40
                     state._fsp--;
 19262  20
 
 19263  20
                     stream_expression.add(expression392.getTree());
 19264  
 
 19265  20
                     CLOSE_BRACE393=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5036);  
 19266  40
                     stream_CLOSE_BRACE.add(CLOSE_BRACE393);
 19267  
 
 19268  20
 
 19269  
                     // AST REWRITE
 19270  
                     // elements: expression, LANG
 19271  
                     // token labels: 
 19272  
                     // rule labels: retval
 19273  
                     // token list labels: 
 19274  20
                     // rule list labels: 
 19275  
                     // wildcard labels: 
 19276  20
                     retval.tree = root_0;
 19277  40
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19278  
 
 19279  20
                     root_0 = (Object)adaptor.nil();
 19280  
                     // 541:46: -> ^( LANG expression )
 19281  15
                     {
 19282  15
                         // com\\googlecode\\sparkleg\\Sparql.g:541:49: ^( LANG expression )
 19283  
                         {
 19284  20
                         Object root_1 = (Object)adaptor.nil();
 19285  35
                         root_1 = (Object)adaptor.becomeRoot(
 19286  15
                         stream_LANG.nextNode()
 19287  
                         , root_1);
 19288  
 
 19289  35
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19290  15
 
 19291  20
                         adaptor.addChild(root_0, root_1);
 19292  15
                         }
 19293  
 
 19294  15
                     }
 19295  
 
 19296  15
 
 19297  35
                     retval.tree = root_0;
 19298  
 
 19299  
                     }
 19300  35
                     break;
 19301  15
                 case 3 :
 19302  
                     // com\\googlecode\\sparkleg\\Sparql.g:542:7: LANGMATCHES OPEN_BRACE expression COMMA expression CLOSE_BRACE
 19303  15
                     {
 19304  15
                     LANGMATCHES394=(Token)match(input,LANGMATCHES,FOLLOW_LANGMATCHES_in_builtInCall5052);  
 19305  30
                     stream_LANGMATCHES.add(LANGMATCHES394);
 19306  
 
 19307  15
 
 19308  30
                     OPEN_BRACE395=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5054);  
 19309  15
                     stream_OPEN_BRACE.add(OPEN_BRACE395);
 19310  
 
 19311  
 
 19312  15
                     pushFollow(FOLLOW_expression_in_builtInCall5056);
 19313  15
                     expression396=expression();
 19314  
 
 19315  15
                     state._fsp--;
 19316  
 
 19317  15
                     stream_expression.add(expression396.getTree());
 19318  15
 
 19319  30
                     COMMA397=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5058);  
 19320  15
                     stream_COMMA.add(COMMA397);
 19321  15
 
 19322  
 
 19323  15
                     pushFollow(FOLLOW_expression_in_builtInCall5060);
 19324  15
                     expression398=expression();
 19325  
 
 19326  30
                     state._fsp--;
 19327  15
 
 19328  15
                     stream_expression.add(expression398.getTree());
 19329  
 
 19330  15
                     CLOSE_BRACE399=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5062);  
 19331  30
                     stream_CLOSE_BRACE.add(CLOSE_BRACE399);
 19332  
 
 19333  
 
 19334  45
                     // AST REWRITE
 19335  30
                     // elements: LANGMATCHES, expression
 19336  
                     // token labels: 
 19337  
                     // rule labels: retval
 19338  15
                     // token list labels: 
 19339  
                     // rule list labels: 
 19340  15
                     // wildcard labels: 
 19341  15
                     retval.tree = root_0;
 19342  15
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19343  
 
 19344  15
                     root_0 = (Object)adaptor.nil();
 19345  
                     // 542:70: -> ^( LANGMATCHES ( expression )+ )
 19346  15
                     {
 19347  
                         // com\\googlecode\\sparkleg\\Sparql.g:542:73: ^( LANGMATCHES ( expression )+ )
 19348  
                         {
 19349  30
                         Object root_1 = (Object)adaptor.nil();
 19350  15
                         root_1 = (Object)adaptor.becomeRoot(
 19351  
                         stream_LANGMATCHES.nextNode()
 19352  
                         , root_1);
 19353  50
 
 19354  65
                         if ( !(stream_expression.hasNext()) ) {
 19355  0
                             throw new RewriteEarlyExitException();
 19356  
                         }
 19357  95
                         while ( stream_expression.hasNext() ) {
 19358  80
                             adaptor.addChild(root_1, stream_expression.nextTree());
 19359  
 
 19360  
                         }
 19361  65
                         stream_expression.reset();
 19362  50
 
 19363  15
                         adaptor.addChild(root_0, root_1);
 19364  50
                         }
 19365  
 
 19366  50
                     }
 19367  
 
 19368  50
 
 19369  65
                     retval.tree = root_0;
 19370  
 
 19371  
                     }
 19372  15
                     break;
 19373  
                 case 4 :
 19374  
                     // com\\googlecode\\sparkleg\\Sparql.g:543:7: DATATYPE OPEN_BRACE expression CLOSE_BRACE
 19375  
                     {
 19376  50
                     DATATYPE400=(Token)match(input,DATATYPE,FOLLOW_DATATYPE_in_builtInCall5079);  
 19377  50
                     stream_DATATYPE.add(DATATYPE400);
 19378  
 
 19379  50
 
 19380  100
                     OPEN_BRACE401=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5081);  
 19381  50
                     stream_OPEN_BRACE.add(OPEN_BRACE401);
 19382  50
 
 19383  
 
 19384  50
                     pushFollow(FOLLOW_expression_in_builtInCall5083);
 19385  50
                     expression402=expression();
 19386  
 
 19387  100
                     state._fsp--;
 19388  50
 
 19389  50
                     stream_expression.add(expression402.getTree());
 19390  
 
 19391  50
                     CLOSE_BRACE403=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5085);  
 19392  100
                     stream_CLOSE_BRACE.add(CLOSE_BRACE403);
 19393  
 
 19394  50
 
 19395  
                     // AST REWRITE
 19396  
                     // elements: DATATYPE, expression
 19397  
                     // token labels: 
 19398  
                     // rule labels: retval
 19399  
                     // token list labels: 
 19400  50
                     // rule list labels: 
 19401  
                     // wildcard labels: 
 19402  50
                     retval.tree = root_0;
 19403  100
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19404  
 
 19405  50
                     root_0 = (Object)adaptor.nil();
 19406  
                     // 543:50: -> ^( DATATYPE expression )
 19407  15
                     {
 19408  15
                         // com\\googlecode\\sparkleg\\Sparql.g:543:53: ^( DATATYPE expression )
 19409  
                         {
 19410  50
                         Object root_1 = (Object)adaptor.nil();
 19411  65
                         root_1 = (Object)adaptor.becomeRoot(
 19412  15
                         stream_DATATYPE.nextNode()
 19413  
                         , root_1);
 19414  
 
 19415  65
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19416  15
 
 19417  50
                         adaptor.addChild(root_0, root_1);
 19418  15
                         }
 19419  
 
 19420  15
                     }
 19421  
 
 19422  15
 
 19423  65
                     retval.tree = root_0;
 19424  
 
 19425  
                     }
 19426  50
                     break;
 19427  
                 case 5 :
 19428  
                     // com\\googlecode\\sparkleg\\Sparql.g:544:7: BOUND OPEN_BRACE var CLOSE_BRACE
 19429  
                     {
 19430  15
                     BOUND404=(Token)match(input,BOUND,FOLLOW_BOUND_in_builtInCall5101);  
 19431  15
                     stream_BOUND.add(BOUND404);
 19432  
 
 19433  15
 
 19434  30
                     OPEN_BRACE405=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5103);  
 19435  15
                     stream_OPEN_BRACE.add(OPEN_BRACE405);
 19436  15
 
 19437  
 
 19438  15
                     pushFollow(FOLLOW_var_in_builtInCall5105);
 19439  15
                     var406=var();
 19440  
 
 19441  30
                     state._fsp--;
 19442  15
 
 19443  15
                     stream_var.add(var406.getTree());
 19444  
 
 19445  15
                     CLOSE_BRACE407=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5107);  
 19446  30
                     stream_CLOSE_BRACE.add(CLOSE_BRACE407);
 19447  
 
 19448  15
 
 19449  
                     // AST REWRITE
 19450  
                     // elements: var, BOUND
 19451  
                     // token labels: 
 19452  
                     // rule labels: retval
 19453  
                     // token list labels: 
 19454  15
                     // rule list labels: 
 19455  
                     // wildcard labels: 
 19456  15
                     retval.tree = root_0;
 19457  30
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19458  
 
 19459  15
                     root_0 = (Object)adaptor.nil();
 19460  
                     // 544:40: -> ^( BOUND var )
 19461  1
                     {
 19462  1
                         // com\\googlecode\\sparkleg\\Sparql.g:544:43: ^( BOUND var )
 19463  
                         {
 19464  15
                         Object root_1 = (Object)adaptor.nil();
 19465  16
                         root_1 = (Object)adaptor.becomeRoot(
 19466  1
                         stream_BOUND.nextNode()
 19467  
                         , root_1);
 19468  
 
 19469  16
                         adaptor.addChild(root_1, stream_var.nextTree());
 19470  1
 
 19471  15
                         adaptor.addChild(root_0, root_1);
 19472  1
                         }
 19473  
 
 19474  1
                     }
 19475  
 
 19476  1
 
 19477  16
                     retval.tree = root_0;
 19478  
 
 19479  
                     }
 19480  15
                     break;
 19481  
                 case 6 :
 19482  
                     // com\\googlecode\\sparkleg\\Sparql.g:545:7: IRI OPEN_BRACE expression CLOSE_BRACE
 19483  
                     {
 19484  1
                     IRI408=(Token)match(input,IRI,FOLLOW_IRI_in_builtInCall5123);  
 19485  1
                     stream_IRI.add(IRI408);
 19486  
 
 19487  1
 
 19488  2
                     OPEN_BRACE409=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5125);  
 19489  1
                     stream_OPEN_BRACE.add(OPEN_BRACE409);
 19490  1
 
 19491  
 
 19492  1
                     pushFollow(FOLLOW_expression_in_builtInCall5127);
 19493  1
                     expression410=expression();
 19494  
 
 19495  2
                     state._fsp--;
 19496  1
 
 19497  1
                     stream_expression.add(expression410.getTree());
 19498  
 
 19499  1
                     CLOSE_BRACE411=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5129);  
 19500  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE411);
 19501  
 
 19502  1
 
 19503  
                     // AST REWRITE
 19504  
                     // elements: expression, IRI
 19505  
                     // token labels: 
 19506  
                     // rule labels: retval
 19507  
                     // token list labels: 
 19508  1
                     // rule list labels: 
 19509  
                     // wildcard labels: 
 19510  1
                     retval.tree = root_0;
 19511  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19512  
 
 19513  1
                     root_0 = (Object)adaptor.nil();
 19514  
                     // 545:45: -> ^( IRI expression )
 19515  1
                     {
 19516  1
                         // com\\googlecode\\sparkleg\\Sparql.g:545:48: ^( IRI expression )
 19517  
                         {
 19518  1
                         Object root_1 = (Object)adaptor.nil();
 19519  2
                         root_1 = (Object)adaptor.becomeRoot(
 19520  1
                         stream_IRI.nextNode()
 19521  
                         , root_1);
 19522  
 
 19523  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19524  1
 
 19525  1
                         adaptor.addChild(root_0, root_1);
 19526  1
                         }
 19527  
 
 19528  1
                     }
 19529  
 
 19530  1
 
 19531  2
                     retval.tree = root_0;
 19532  
 
 19533  
                     }
 19534  1
                     break;
 19535  
                 case 7 :
 19536  
                     // com\\googlecode\\sparkleg\\Sparql.g:546:7: URI OPEN_BRACE expression CLOSE_BRACE
 19537  
                     {
 19538  1
                     URI412=(Token)match(input,URI,FOLLOW_URI_in_builtInCall5145);  
 19539  1
                     stream_URI.add(URI412);
 19540  
 
 19541  1
 
 19542  2
                     OPEN_BRACE413=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5147);  
 19543  1
                     stream_OPEN_BRACE.add(OPEN_BRACE413);
 19544  1
 
 19545  
 
 19546  1
                     pushFollow(FOLLOW_expression_in_builtInCall5149);
 19547  1
                     expression414=expression();
 19548  
 
 19549  2
                     state._fsp--;
 19550  1
 
 19551  1
                     stream_expression.add(expression414.getTree());
 19552  
 
 19553  1
                     CLOSE_BRACE415=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5151);  
 19554  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE415);
 19555  
 
 19556  1
 
 19557  
                     // AST REWRITE
 19558  
                     // elements: expression, URI
 19559  
                     // token labels: 
 19560  
                     // rule labels: retval
 19561  
                     // token list labels: 
 19562  1
                     // rule list labels: 
 19563  
                     // wildcard labels: 
 19564  1
                     retval.tree = root_0;
 19565  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19566  
 
 19567  1
                     root_0 = (Object)adaptor.nil();
 19568  
                     // 546:45: -> ^( URI expression )
 19569  2
                     {
 19570  2
                         // com\\googlecode\\sparkleg\\Sparql.g:546:48: ^( URI expression )
 19571  
                         {
 19572  1
                         Object root_1 = (Object)adaptor.nil();
 19573  1
                         root_1 = (Object)adaptor.becomeRoot(
 19574  
                         stream_URI.nextNode()
 19575  
                         , root_1);
 19576  2
 
 19577  3
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19578  
 
 19579  1
                         adaptor.addChild(root_0, root_1);
 19580  2
                         }
 19581  2
 
 19582  
                     }
 19583  2
 
 19584  
 
 19585  3
                     retval.tree = root_0;
 19586  
 
 19587  2
                     }
 19588  3
                     break;
 19589  
                 case 8 :
 19590  
                     // com\\googlecode\\sparkleg\\Sparql.g:547:7: BNODE ( OPEN_BRACE expression CLOSE_BRACE )
 19591  
                     {
 19592  2
                     BNODE416=(Token)match(input,BNODE,FOLLOW_BNODE_in_builtInCall5167);  
 19593  2
                     stream_BNODE.add(BNODE416);
 19594  
 
 19595  
 
 19596  
                     // com\\googlecode\\sparkleg\\Sparql.g:547:13: ( OPEN_BRACE expression CLOSE_BRACE )
 19597  
                     // com\\googlecode\\sparkleg\\Sparql.g:547:14: OPEN_BRACE expression CLOSE_BRACE
 19598  
                     {
 19599  2
                     OPEN_BRACE417=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5170);  
 19600  2
                     stream_OPEN_BRACE.add(OPEN_BRACE417);
 19601  2
 
 19602  2
 
 19603  2
                     pushFollow(FOLLOW_expression_in_builtInCall5172);
 19604  4
                     expression418=expression();
 19605  
 
 19606  2
                     state._fsp--;
 19607  
 
 19608  2
                     stream_expression.add(expression418.getTree());
 19609  2
 
 19610  4
                     CLOSE_BRACE419=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5174);  
 19611  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE419);
 19612  
 
 19613  
 
 19614  2
                     }
 19615  
 
 19616  2
 
 19617  
                     // AST REWRITE
 19618  
                     // elements: BNODE, expression
 19619  
                     // token labels: 
 19620  
                     // rule labels: retval
 19621  
                     // token list labels: 
 19622  2
                     // rule list labels: 
 19623  
                     // wildcard labels: 
 19624  2
                     retval.tree = root_0;
 19625  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19626  
 
 19627  2
                     root_0 = (Object)adaptor.nil();
 19628  
                     // 547:49: -> ^( BNODE expression )
 19629  2
                     {
 19630  2
                         // com\\googlecode\\sparkleg\\Sparql.g:547:52: ^( BNODE expression )
 19631  
                         {
 19632  2
                         Object root_1 = (Object)adaptor.nil();
 19633  4
                         root_1 = (Object)adaptor.becomeRoot(
 19634  2
                         stream_BNODE.nextNode()
 19635  
                         , root_1);
 19636  2
 
 19637  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19638  2
 
 19639  2
                         adaptor.addChild(root_0, root_1);
 19640  
                         }
 19641  
 
 19642  
                     }
 19643  
 
 19644  
 
 19645  2
                     retval.tree = root_0;
 19646  
 
 19647  2
                     }
 19648  4
                     break;
 19649  
                 case 9 :
 19650  2
                     // com\\googlecode\\sparkleg\\Sparql.g:548:7: BNODE nil
 19651  
                     {
 19652  2
                     BNODE420=(Token)match(input,BNODE,FOLLOW_BNODE_in_builtInCall5191);  
 19653  4
                     stream_BNODE.add(BNODE420);
 19654  
 
 19655  
 
 19656  2
                     pushFollow(FOLLOW_nil_in_builtInCall5193);
 19657  2
                     nil421=nil();
 19658  
 
 19659  2
                     state._fsp--;
 19660  2
 
 19661  2
                     stream_nil.add(nil421.getTree());
 19662  
 
 19663  2
                     // AST REWRITE
 19664  
                     // elements: BNODE
 19665  
                     // token labels: 
 19666  
                     // rule labels: retval
 19667  1
                     // token list labels: 
 19668  1
                     // rule list labels: 
 19669  
                     // wildcard labels: 
 19670  2
                     retval.tree = root_0;
 19671  3
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19672  1
 
 19673  2
                     root_0 = (Object)adaptor.nil();
 19674  1
                     // 548:17: -> BNODE
 19675  
                     {
 19676  3
                         adaptor.addChild(root_0, 
 19677  
                         stream_BNODE.nextNode()
 19678  
                         );
 19679  
 
 19680  
                     }
 19681  
 
 19682  
 
 19683  2
                     retval.tree = root_0;
 19684  
 
 19685  1
                     }
 19686  3
                     break;
 19687  
                 case 10 :
 19688  1
                     // com\\googlecode\\sparkleg\\Sparql.g:549:7: RAND nil
 19689  
                     {
 19690  1
                     RAND422=(Token)match(input,RAND,FOLLOW_RAND_in_builtInCall5205);  
 19691  2
                     stream_RAND.add(RAND422);
 19692  
 
 19693  
 
 19694  1
                     pushFollow(FOLLOW_nil_in_builtInCall5207);
 19695  1
                     nil423=nil();
 19696  
 
 19697  1
                     state._fsp--;
 19698  1
 
 19699  1
                     stream_nil.add(nil423.getTree());
 19700  
 
 19701  1
                     // AST REWRITE
 19702  
                     // elements: RAND
 19703  
                     // token labels: 
 19704  
                     // rule labels: retval
 19705  1
                     // token list labels: 
 19706  1
                     // rule list labels: 
 19707  
                     // wildcard labels: 
 19708  1
                     retval.tree = root_0;
 19709  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19710  1
 
 19711  1
                     root_0 = (Object)adaptor.nil();
 19712  
                     // 549:16: -> RAND
 19713  1
                     {
 19714  2
                         adaptor.addChild(root_0, 
 19715  
                         stream_RAND.nextNode()
 19716  1
                         );
 19717  
 
 19718  1
                     }
 19719  
 
 19720  1
 
 19721  2
                     retval.tree = root_0;
 19722  
 
 19723  
                     }
 19724  1
                     break;
 19725  
                 case 11 :
 19726  
                     // com\\googlecode\\sparkleg\\Sparql.g:550:7: ABS OPEN_BRACE expression CLOSE_BRACE
 19727  
                     {
 19728  1
                     ABS424=(Token)match(input,ABS,FOLLOW_ABS_in_builtInCall5219);  
 19729  1
                     stream_ABS.add(ABS424);
 19730  
 
 19731  1
 
 19732  2
                     OPEN_BRACE425=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5221);  
 19733  1
                     stream_OPEN_BRACE.add(OPEN_BRACE425);
 19734  1
 
 19735  
 
 19736  1
                     pushFollow(FOLLOW_expression_in_builtInCall5223);
 19737  1
                     expression426=expression();
 19738  
 
 19739  2
                     state._fsp--;
 19740  1
 
 19741  1
                     stream_expression.add(expression426.getTree());
 19742  
 
 19743  1
                     CLOSE_BRACE427=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5225);  
 19744  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE427);
 19745  
 
 19746  1
 
 19747  
                     // AST REWRITE
 19748  
                     // elements: ABS, expression
 19749  
                     // token labels: 
 19750  
                     // rule labels: retval
 19751  
                     // token list labels: 
 19752  1
                     // rule list labels: 
 19753  
                     // wildcard labels: 
 19754  1
                     retval.tree = root_0;
 19755  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19756  
 
 19757  1
                     root_0 = (Object)adaptor.nil();
 19758  
                     // 550:45: -> ^( ABS expression )
 19759  1
                     {
 19760  1
                         // com\\googlecode\\sparkleg\\Sparql.g:550:48: ^( ABS expression )
 19761  
                         {
 19762  1
                         Object root_1 = (Object)adaptor.nil();
 19763  2
                         root_1 = (Object)adaptor.becomeRoot(
 19764  1
                         stream_ABS.nextNode()
 19765  
                         , root_1);
 19766  
 
 19767  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19768  1
 
 19769  1
                         adaptor.addChild(root_0, root_1);
 19770  1
                         }
 19771  
 
 19772  1
                     }
 19773  
 
 19774  1
 
 19775  2
                     retval.tree = root_0;
 19776  
 
 19777  
                     }
 19778  1
                     break;
 19779  
                 case 12 :
 19780  
                     // com\\googlecode\\sparkleg\\Sparql.g:551:7: CEIL OPEN_BRACE expression CLOSE_BRACE
 19781  
                     {
 19782  1
                     CEIL428=(Token)match(input,CEIL,FOLLOW_CEIL_in_builtInCall5241);  
 19783  1
                     stream_CEIL.add(CEIL428);
 19784  
 
 19785  1
 
 19786  2
                     OPEN_BRACE429=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5243);  
 19787  1
                     stream_OPEN_BRACE.add(OPEN_BRACE429);
 19788  1
 
 19789  
 
 19790  1
                     pushFollow(FOLLOW_expression_in_builtInCall5245);
 19791  1
                     expression430=expression();
 19792  
 
 19793  2
                     state._fsp--;
 19794  1
 
 19795  1
                     stream_expression.add(expression430.getTree());
 19796  
 
 19797  1
                     CLOSE_BRACE431=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5247);  
 19798  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE431);
 19799  
 
 19800  1
 
 19801  
                     // AST REWRITE
 19802  
                     // elements: expression, CEIL
 19803  
                     // token labels: 
 19804  
                     // rule labels: retval
 19805  
                     // token list labels: 
 19806  1
                     // rule list labels: 
 19807  
                     // wildcard labels: 
 19808  1
                     retval.tree = root_0;
 19809  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19810  
 
 19811  1
                     root_0 = (Object)adaptor.nil();
 19812  
                     // 551:46: -> ^( CEIL expression )
 19813  1
                     {
 19814  1
                         // com\\googlecode\\sparkleg\\Sparql.g:551:49: ^( CEIL expression )
 19815  
                         {
 19816  1
                         Object root_1 = (Object)adaptor.nil();
 19817  2
                         root_1 = (Object)adaptor.becomeRoot(
 19818  1
                         stream_CEIL.nextNode()
 19819  
                         , root_1);
 19820  
 
 19821  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19822  1
 
 19823  1
                         adaptor.addChild(root_0, root_1);
 19824  1
                         }
 19825  
 
 19826  1
                     }
 19827  
 
 19828  1
 
 19829  2
                     retval.tree = root_0;
 19830  
 
 19831  
                     }
 19832  1
                     break;
 19833  
                 case 13 :
 19834  
                     // com\\googlecode\\sparkleg\\Sparql.g:552:7: FLOOR OPEN_BRACE expression CLOSE_BRACE
 19835  
                     {
 19836  1
                     FLOOR432=(Token)match(input,FLOOR,FOLLOW_FLOOR_in_builtInCall5263);  
 19837  1
                     stream_FLOOR.add(FLOOR432);
 19838  
 
 19839  1
 
 19840  2
                     OPEN_BRACE433=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5265);  
 19841  1
                     stream_OPEN_BRACE.add(OPEN_BRACE433);
 19842  1
 
 19843  
 
 19844  1
                     pushFollow(FOLLOW_expression_in_builtInCall5267);
 19845  1
                     expression434=expression();
 19846  
 
 19847  2
                     state._fsp--;
 19848  1
 
 19849  1
                     stream_expression.add(expression434.getTree());
 19850  
 
 19851  1
                     CLOSE_BRACE435=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5269);  
 19852  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE435);
 19853  
 
 19854  1
 
 19855  
                     // AST REWRITE
 19856  
                     // elements: FLOOR, expression
 19857  
                     // token labels: 
 19858  
                     // rule labels: retval
 19859  
                     // token list labels: 
 19860  1
                     // rule list labels: 
 19861  
                     // wildcard labels: 
 19862  1
                     retval.tree = root_0;
 19863  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19864  
 
 19865  1
                     root_0 = (Object)adaptor.nil();
 19866  
                     // 552:47: -> ^( FLOOR expression )
 19867  1
                     {
 19868  1
                         // com\\googlecode\\sparkleg\\Sparql.g:552:50: ^( FLOOR expression )
 19869  
                         {
 19870  1
                         Object root_1 = (Object)adaptor.nil();
 19871  2
                         root_1 = (Object)adaptor.becomeRoot(
 19872  1
                         stream_FLOOR.nextNode()
 19873  
                         , root_1);
 19874  
 
 19875  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19876  1
 
 19877  1
                         adaptor.addChild(root_0, root_1);
 19878  1
                         }
 19879  
 
 19880  1
                     }
 19881  
 
 19882  1
 
 19883  2
                     retval.tree = root_0;
 19884  
 
 19885  
                     }
 19886  1
                     break;
 19887  
                 case 14 :
 19888  
                     // com\\googlecode\\sparkleg\\Sparql.g:553:7: ROUND OPEN_BRACE expression CLOSE_BRACE
 19889  
                     {
 19890  1
                     ROUND436=(Token)match(input,ROUND,FOLLOW_ROUND_in_builtInCall5285);  
 19891  1
                     stream_ROUND.add(ROUND436);
 19892  
 
 19893  1
 
 19894  2
                     OPEN_BRACE437=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5287);  
 19895  1
                     stream_OPEN_BRACE.add(OPEN_BRACE437);
 19896  1
 
 19897  
 
 19898  1
                     pushFollow(FOLLOW_expression_in_builtInCall5289);
 19899  1
                     expression438=expression();
 19900  
 
 19901  2
                     state._fsp--;
 19902  1
 
 19903  1
                     stream_expression.add(expression438.getTree());
 19904  
 
 19905  1
                     CLOSE_BRACE439=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5291);  
 19906  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE439);
 19907  
 
 19908  1
 
 19909  
                     // AST REWRITE
 19910  
                     // elements: expression, ROUND
 19911  
                     // token labels: 
 19912  
                     // rule labels: retval
 19913  
                     // token list labels: 
 19914  1
                     // rule list labels: 
 19915  
                     // wildcard labels: 
 19916  1
                     retval.tree = root_0;
 19917  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19918  
 
 19919  1
                     root_0 = (Object)adaptor.nil();
 19920  
                     // 553:47: -> ^( ROUND expression )
 19921  5
                     {
 19922  5
                         // com\\googlecode\\sparkleg\\Sparql.g:553:50: ^( ROUND expression )
 19923  
                         {
 19924  1
                         Object root_1 = (Object)adaptor.nil();
 19925  6
                         root_1 = (Object)adaptor.becomeRoot(
 19926  5
                         stream_ROUND.nextNode()
 19927  
                         , root_1);
 19928  5
 
 19929  1
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19930  5
 
 19931  1
                         adaptor.addChild(root_0, root_1);
 19932  
                         }
 19933  
 
 19934  
                     }
 19935  
 
 19936  
 
 19937  1
                     retval.tree = root_0;
 19938  
 
 19939  5
                     }
 19940  6
                     break;
 19941  
                 case 15 :
 19942  5
                     // com\\googlecode\\sparkleg\\Sparql.g:554:7: CONCAT expressionList
 19943  
                     {
 19944  5
                     CONCAT440=(Token)match(input,CONCAT,FOLLOW_CONCAT_in_builtInCall5307);  
 19945  5
                     stream_CONCAT.add(CONCAT440);
 19946  
 
 19947  5
 
 19948  10
                     pushFollow(FOLLOW_expressionList_in_builtInCall5309);
 19949  5
                     expressionList441=expressionList();
 19950  
 
 19951  5
                     state._fsp--;
 19952  5
 
 19953  5
                     stream_expressionList.add(expressionList441.getTree());
 19954  5
 
 19955  
                     // AST REWRITE
 19956  
                     // elements: expressionList, CONCAT
 19957  
                     // token labels: 
 19958  
                     // rule labels: retval
 19959  
                     // token list labels: 
 19960  5
                     // rule list labels: 
 19961  
                     // wildcard labels: 
 19962  5
                     retval.tree = root_0;
 19963  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19964  
 
 19965  5
                     root_0 = (Object)adaptor.nil();
 19966  
                     // 554:29: -> ^( CONCAT expressionList )
 19967  2
                     {
 19968  2
                         // com\\googlecode\\sparkleg\\Sparql.g:554:32: ^( CONCAT expressionList )
 19969  
                         {
 19970  7
                         Object root_1 = (Object)adaptor.nil();
 19971  5
                         root_1 = (Object)adaptor.becomeRoot(
 19972  2
                         stream_CONCAT.nextNode()
 19973  
                         , root_1);
 19974  
 
 19975  5
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 19976  
 
 19977  5
                         adaptor.addChild(root_0, root_1);
 19978  
                         }
 19979  
 
 19980  
                     }
 19981  2
 
 19982  2
 
 19983  5
                     retval.tree = root_0;
 19984  2
 
 19985  
                     }
 19986  5
                     break;
 19987  2
                 case 16 :
 19988  
                     // com\\googlecode\\sparkleg\\Sparql.g:555:7: subStringExpression
 19989  
                     {
 19990  2
                     pushFollow(FOLLOW_subStringExpression_in_builtInCall5325);
 19991  2
                     subStringExpression442=subStringExpression();
 19992  2
 
 19993  2
                     state._fsp--;
 19994  
 
 19995  4
                     stream_subStringExpression.add(subStringExpression442.getTree());
 19996  
 
 19997  
                     // AST REWRITE
 19998  
                     // elements: subStringExpression
 19999  1
                     // token labels: 
 20000  1
                     // rule labels: retval
 20001  
                     // token list labels: 
 20002  
                     // rule list labels: 
 20003  1
                     // wildcard labels: 
 20004  3
                     retval.tree = root_0;
 20005  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20006  
 
 20007  3
                     root_0 = (Object)adaptor.nil();
 20008  1
                     // 555:27: -> subStringExpression
 20009  
                     {
 20010  3
                         adaptor.addChild(root_0, stream_subStringExpression.nextTree());
 20011  
 
 20012  1
                     }
 20013  
 
 20014  1
 
 20015  3
                     retval.tree = root_0;
 20016  
 
 20017  
                     }
 20018  2
                     break;
 20019  
                 case 17 :
 20020  
                     // com\\googlecode\\sparkleg\\Sparql.g:556:7: STRLEN OPEN_BRACE expression CLOSE_BRACE
 20021  
                     {
 20022  1
                     STRLEN443=(Token)match(input,STRLEN,FOLLOW_STRLEN_in_builtInCall5337);  
 20023  1
                     stream_STRLEN.add(STRLEN443);
 20024  
 
 20025  1
 
 20026  2
                     OPEN_BRACE444=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5339);  
 20027  1
                     stream_OPEN_BRACE.add(OPEN_BRACE444);
 20028  1
 
 20029  
 
 20030  1
                     pushFollow(FOLLOW_expression_in_builtInCall5341);
 20031  1
                     expression445=expression();
 20032  
 
 20033  2
                     state._fsp--;
 20034  1
 
 20035  1
                     stream_expression.add(expression445.getTree());
 20036  
 
 20037  1
                     CLOSE_BRACE446=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5343);  
 20038  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE446);
 20039  
 
 20040  1
 
 20041  
                     // AST REWRITE
 20042  
                     // elements: STRLEN, expression
 20043  
                     // token labels: 
 20044  
                     // rule labels: retval
 20045  
                     // token list labels: 
 20046  1
                     // rule list labels: 
 20047  
                     // wildcard labels: 
 20048  1
                     retval.tree = root_0;
 20049  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20050  
 
 20051  1
                     root_0 = (Object)adaptor.nil();
 20052  
                     // 556:48: -> ^( STRLEN expression )
 20053  1
                     {
 20054  1
                         // com\\googlecode\\sparkleg\\Sparql.g:556:51: ^( STRLEN expression )
 20055  
                         {
 20056  1
                         Object root_1 = (Object)adaptor.nil();
 20057  2
                         root_1 = (Object)adaptor.becomeRoot(
 20058  1
                         stream_STRLEN.nextNode()
 20059  
                         , root_1);
 20060  
 
 20061  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20062  1
 
 20063  1
                         adaptor.addChild(root_0, root_1);
 20064  1
                         }
 20065  
 
 20066  1
                     }
 20067  
 
 20068  1
 
 20069  2
                     retval.tree = root_0;
 20070  
 
 20071  
                     }
 20072  1
                     break;
 20073  
                 case 18 :
 20074  
                     // com\\googlecode\\sparkleg\\Sparql.g:557:7: UCASE OPEN_BRACE expression CLOSE_BRACE
 20075  
                     {
 20076  1
                     UCASE447=(Token)match(input,UCASE,FOLLOW_UCASE_in_builtInCall5359);  
 20077  1
                     stream_UCASE.add(UCASE447);
 20078  
 
 20079  1
 
 20080  2
                     OPEN_BRACE448=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5361);  
 20081  1
                     stream_OPEN_BRACE.add(OPEN_BRACE448);
 20082  1
 
 20083  
 
 20084  1
                     pushFollow(FOLLOW_expression_in_builtInCall5363);
 20085  1
                     expression449=expression();
 20086  
 
 20087  2
                     state._fsp--;
 20088  1
 
 20089  1
                     stream_expression.add(expression449.getTree());
 20090  
 
 20091  1
                     CLOSE_BRACE450=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5365);  
 20092  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE450);
 20093  
 
 20094  1
 
 20095  
                     // AST REWRITE
 20096  
                     // elements: expression, UCASE
 20097  
                     // token labels: 
 20098  
                     // rule labels: retval
 20099  
                     // token list labels: 
 20100  1
                     // rule list labels: 
 20101  
                     // wildcard labels: 
 20102  1
                     retval.tree = root_0;
 20103  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20104  
 
 20105  1
                     root_0 = (Object)adaptor.nil();
 20106  
                     // 557:47: -> ^( UCASE expression )
 20107  1
                     {
 20108  1
                         // com\\googlecode\\sparkleg\\Sparql.g:557:50: ^( UCASE expression )
 20109  
                         {
 20110  1
                         Object root_1 = (Object)adaptor.nil();
 20111  2
                         root_1 = (Object)adaptor.becomeRoot(
 20112  1
                         stream_UCASE.nextNode()
 20113  
                         , root_1);
 20114  
 
 20115  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20116  1
 
 20117  1
                         adaptor.addChild(root_0, root_1);
 20118  1
                         }
 20119  
 
 20120  1
                     }
 20121  
 
 20122  1
 
 20123  2
                     retval.tree = root_0;
 20124  
 
 20125  
                     }
 20126  1
                     break;
 20127  
                 case 19 :
 20128  
                     // com\\googlecode\\sparkleg\\Sparql.g:558:7: LCASE OPEN_BRACE expression CLOSE_BRACE
 20129  
                     {
 20130  1
                     LCASE451=(Token)match(input,LCASE,FOLLOW_LCASE_in_builtInCall5381);  
 20131  1
                     stream_LCASE.add(LCASE451);
 20132  
 
 20133  1
 
 20134  2
                     OPEN_BRACE452=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5383);  
 20135  1
                     stream_OPEN_BRACE.add(OPEN_BRACE452);
 20136  1
 
 20137  
 
 20138  1
                     pushFollow(FOLLOW_expression_in_builtInCall5385);
 20139  1
                     expression453=expression();
 20140  
 
 20141  2
                     state._fsp--;
 20142  1
 
 20143  1
                     stream_expression.add(expression453.getTree());
 20144  
 
 20145  1
                     CLOSE_BRACE454=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5387);  
 20146  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE454);
 20147  
 
 20148  1
 
 20149  
                     // AST REWRITE
 20150  
                     // elements: expression, LCASE
 20151  
                     // token labels: 
 20152  
                     // rule labels: retval
 20153  
                     // token list labels: 
 20154  1
                     // rule list labels: 
 20155  
                     // wildcard labels: 
 20156  1
                     retval.tree = root_0;
 20157  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20158  
 
 20159  1
                     root_0 = (Object)adaptor.nil();
 20160  
                     // 558:47: -> ^( LCASE expression )
 20161  1
                     {
 20162  1
                         // com\\googlecode\\sparkleg\\Sparql.g:558:50: ^( LCASE expression )
 20163  
                         {
 20164  1
                         Object root_1 = (Object)adaptor.nil();
 20165  2
                         root_1 = (Object)adaptor.becomeRoot(
 20166  1
                         stream_LCASE.nextNode()
 20167  
                         , root_1);
 20168  
 
 20169  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20170  1
 
 20171  1
                         adaptor.addChild(root_0, root_1);
 20172  1
                         }
 20173  
 
 20174  1
                     }
 20175  
 
 20176  1
 
 20177  2
                     retval.tree = root_0;
 20178  
 
 20179  
                     }
 20180  1
                     break;
 20181  
                 case 20 :
 20182  
                     // com\\googlecode\\sparkleg\\Sparql.g:559:7: ENCODE_FOR_URI OPEN_BRACE expression CLOSE_BRACE
 20183  
                     {
 20184  1
                     ENCODE_FOR_URI455=(Token)match(input,ENCODE_FOR_URI,FOLLOW_ENCODE_FOR_URI_in_builtInCall5403);  
 20185  1
                     stream_ENCODE_FOR_URI.add(ENCODE_FOR_URI455);
 20186  
 
 20187  1
 
 20188  2
                     OPEN_BRACE456=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5405);  
 20189  1
                     stream_OPEN_BRACE.add(OPEN_BRACE456);
 20190  1
 
 20191  
 
 20192  1
                     pushFollow(FOLLOW_expression_in_builtInCall5407);
 20193  1
                     expression457=expression();
 20194  
 
 20195  2
                     state._fsp--;
 20196  1
 
 20197  1
                     stream_expression.add(expression457.getTree());
 20198  
 
 20199  1
                     CLOSE_BRACE458=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5409);  
 20200  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE458);
 20201  
 
 20202  1
 
 20203  
                     // AST REWRITE
 20204  
                     // elements: expression, ENCODE_FOR_URI
 20205  
                     // token labels: 
 20206  
                     // rule labels: retval
 20207  
                     // token list labels: 
 20208  1
                     // rule list labels: 
 20209  
                     // wildcard labels: 
 20210  1
                     retval.tree = root_0;
 20211  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20212  
 
 20213  1
                     root_0 = (Object)adaptor.nil();
 20214  
                     // 559:56: -> ^( ENCODE_FOR_URI expression )
 20215  1
                     {
 20216  1
                         // com\\googlecode\\sparkleg\\Sparql.g:559:59: ^( ENCODE_FOR_URI expression )
 20217  
                         {
 20218  1
                         Object root_1 = (Object)adaptor.nil();
 20219  2
                         root_1 = (Object)adaptor.becomeRoot(
 20220  1
                         stream_ENCODE_FOR_URI.nextNode()
 20221  
                         , root_1);
 20222  
 
 20223  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20224  1
 
 20225  1
                         adaptor.addChild(root_0, root_1);
 20226  1
                         }
 20227  
 
 20228  1
                     }
 20229  
 
 20230  1
 
 20231  2
                     retval.tree = root_0;
 20232  
 
 20233  
                     }
 20234  2
                     break;
 20235  1
                 case 21 :
 20236  
                     // com\\googlecode\\sparkleg\\Sparql.g:560:7: CONTAINS OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20237  1
                     {
 20238  1
                     CONTAINS459=(Token)match(input,CONTAINS,FOLLOW_CONTAINS_in_builtInCall5425);  
 20239  2
                     stream_CONTAINS.add(CONTAINS459);
 20240  
 
 20241  1
 
 20242  2
                     OPEN_BRACE460=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5427);  
 20243  1
                     stream_OPEN_BRACE.add(OPEN_BRACE460);
 20244  
 
 20245  
 
 20246  1
                     pushFollow(FOLLOW_expression_in_builtInCall5429);
 20247  1
                     expression461=expression();
 20248  
 
 20249  1
                     state._fsp--;
 20250  
 
 20251  1
                     stream_expression.add(expression461.getTree());
 20252  1
 
 20253  2
                     COMMA462=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5431);  
 20254  1
                     stream_COMMA.add(COMMA462);
 20255  1
 
 20256  
 
 20257  1
                     pushFollow(FOLLOW_expression_in_builtInCall5433);
 20258  1
                     expression463=expression();
 20259  
 
 20260  2
                     state._fsp--;
 20261  1
 
 20262  1
                     stream_expression.add(expression463.getTree());
 20263  
 
 20264  1
                     CLOSE_BRACE464=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5435);  
 20265  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE464);
 20266  
 
 20267  1
 
 20268  
                     // AST REWRITE
 20269  1
                     // elements: expression, expression, CONTAINS
 20270  
                     // token labels: 
 20271  
                     // rule labels: retval
 20272  
                     // token list labels: 
 20273  
                     // rule list labels: 
 20274  
                     // wildcard labels: 
 20275  2
                     retval.tree = root_0;
 20276  1
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20277  
 
 20278  2
                     root_0 = (Object)adaptor.nil();
 20279  
                     // 560:67: -> ^( CONTAINS expression expression )
 20280  
                     {
 20281  
                         // com\\googlecode\\sparkleg\\Sparql.g:560:70: ^( CONTAINS expression expression )
 20282  1
                         {
 20283  2
                         Object root_1 = (Object)adaptor.nil();
 20284  1
                         root_1 = (Object)adaptor.becomeRoot(
 20285  
                         stream_CONTAINS.nextNode()
 20286  1
                         , root_1);
 20287  1
 
 20288  1
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20289  
 
 20290  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20291  1
 
 20292  1
                         adaptor.addChild(root_0, root_1);
 20293  1
                         }
 20294  
 
 20295  1
                     }
 20296  
 
 20297  1
 
 20298  2
                     retval.tree = root_0;
 20299  
 
 20300  
                     }
 20301  2
                     break;
 20302  1
                 case 22 :
 20303  
                     // com\\googlecode\\sparkleg\\Sparql.g:561:7: STRSTARTS OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20304  1
                     {
 20305  1
                     STRSTARTS465=(Token)match(input,STRSTARTS,FOLLOW_STRSTARTS_in_builtInCall5453);  
 20306  2
                     stream_STRSTARTS.add(STRSTARTS465);
 20307  
 
 20308  1
 
 20309  2
                     OPEN_BRACE466=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5455);  
 20310  1
                     stream_OPEN_BRACE.add(OPEN_BRACE466);
 20311  
 
 20312  
 
 20313  1
                     pushFollow(FOLLOW_expression_in_builtInCall5457);
 20314  1
                     expression467=expression();
 20315  
 
 20316  1
                     state._fsp--;
 20317  
 
 20318  1
                     stream_expression.add(expression467.getTree());
 20319  1
 
 20320  2
                     COMMA468=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5459);  
 20321  1
                     stream_COMMA.add(COMMA468);
 20322  1
 
 20323  
 
 20324  1
                     pushFollow(FOLLOW_expression_in_builtInCall5461);
 20325  1
                     expression469=expression();
 20326  
 
 20327  2
                     state._fsp--;
 20328  1
 
 20329  1
                     stream_expression.add(expression469.getTree());
 20330  
 
 20331  1
                     CLOSE_BRACE470=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5463);  
 20332  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE470);
 20333  
 
 20334  1
 
 20335  
                     // AST REWRITE
 20336  1
                     // elements: STRSTARTS, expression, expression
 20337  
                     // token labels: 
 20338  
                     // rule labels: retval
 20339  
                     // token list labels: 
 20340  
                     // rule list labels: 
 20341  
                     // wildcard labels: 
 20342  2
                     retval.tree = root_0;
 20343  1
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20344  
 
 20345  2
                     root_0 = (Object)adaptor.nil();
 20346  
                     // 561:68: -> ^( STRSTARTS expression expression )
 20347  
                     {
 20348  
                         // com\\googlecode\\sparkleg\\Sparql.g:561:71: ^( STRSTARTS expression expression )
 20349  1
                         {
 20350  2
                         Object root_1 = (Object)adaptor.nil();
 20351  1
                         root_1 = (Object)adaptor.becomeRoot(
 20352  
                         stream_STRSTARTS.nextNode()
 20353  1
                         , root_1);
 20354  1
 
 20355  1
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20356  
 
 20357  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20358  1
 
 20359  1
                         adaptor.addChild(root_0, root_1);
 20360  1
                         }
 20361  
 
 20362  1
                     }
 20363  
 
 20364  1
 
 20365  2
                     retval.tree = root_0;
 20366  
 
 20367  
                     }
 20368  2
                     break;
 20369  1
                 case 23 :
 20370  
                     // com\\googlecode\\sparkleg\\Sparql.g:562:7: STRENDS OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20371  1
                     {
 20372  1
                     STRENDS471=(Token)match(input,STRENDS,FOLLOW_STRENDS_in_builtInCall5481);  
 20373  2
                     stream_STRENDS.add(STRENDS471);
 20374  
 
 20375  1
 
 20376  2
                     OPEN_BRACE472=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5483);  
 20377  1
                     stream_OPEN_BRACE.add(OPEN_BRACE472);
 20378  
 
 20379  
 
 20380  1
                     pushFollow(FOLLOW_expression_in_builtInCall5485);
 20381  1
                     expression473=expression();
 20382  
 
 20383  1
                     state._fsp--;
 20384  
 
 20385  1
                     stream_expression.add(expression473.getTree());
 20386  1
 
 20387  2
                     COMMA474=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5487);  
 20388  1
                     stream_COMMA.add(COMMA474);
 20389  1
 
 20390  
 
 20391  1
                     pushFollow(FOLLOW_expression_in_builtInCall5489);
 20392  1
                     expression475=expression();
 20393  
 
 20394  2
                     state._fsp--;
 20395  1
 
 20396  1
                     stream_expression.add(expression475.getTree());
 20397  
 
 20398  1
                     CLOSE_BRACE476=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5491);  
 20399  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE476);
 20400  
 
 20401  1
 
 20402  
                     // AST REWRITE
 20403  1
                     // elements: expression, STRENDS, expression
 20404  
                     // token labels: 
 20405  
                     // rule labels: retval
 20406  
                     // token list labels: 
 20407  
                     // rule list labels: 
 20408  
                     // wildcard labels: 
 20409  2
                     retval.tree = root_0;
 20410  1
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20411  
 
 20412  2
                     root_0 = (Object)adaptor.nil();
 20413  
                     // 562:66: -> ^( STRENDS expression expression )
 20414  
                     {
 20415  
                         // com\\googlecode\\sparkleg\\Sparql.g:562:69: ^( STRENDS expression expression )
 20416  1
                         {
 20417  2
                         Object root_1 = (Object)adaptor.nil();
 20418  1
                         root_1 = (Object)adaptor.becomeRoot(
 20419  
                         stream_STRENDS.nextNode()
 20420  1
                         , root_1);
 20421  1
 
 20422  1
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20423  
 
 20424  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20425  1
 
 20426  1
                         adaptor.addChild(root_0, root_1);
 20427  1
                         }
 20428  
 
 20429  1
                     }
 20430  
 
 20431  1
 
 20432  2
                     retval.tree = root_0;
 20433  
 
 20434  
                     }
 20435  2
                     break;
 20436  1
                 case 24 :
 20437  
                     // com\\googlecode\\sparkleg\\Sparql.g:563:7: STRBEFORE OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20438  1
                     {
 20439  1
                     STRBEFORE477=(Token)match(input,STRBEFORE,FOLLOW_STRBEFORE_in_builtInCall5509);  
 20440  2
                     stream_STRBEFORE.add(STRBEFORE477);
 20441  
 
 20442  1
 
 20443  2
                     OPEN_BRACE478=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5511);  
 20444  1
                     stream_OPEN_BRACE.add(OPEN_BRACE478);
 20445  
 
 20446  
 
 20447  1
                     pushFollow(FOLLOW_expression_in_builtInCall5513);
 20448  1
                     expression479=expression();
 20449  
 
 20450  1
                     state._fsp--;
 20451  
 
 20452  1
                     stream_expression.add(expression479.getTree());
 20453  1
 
 20454  2
                     COMMA480=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5515);  
 20455  1
                     stream_COMMA.add(COMMA480);
 20456  1
 
 20457  
 
 20458  1
                     pushFollow(FOLLOW_expression_in_builtInCall5517);
 20459  1
                     expression481=expression();
 20460  
 
 20461  2
                     state._fsp--;
 20462  1
 
 20463  1
                     stream_expression.add(expression481.getTree());
 20464  
 
 20465  1
                     CLOSE_BRACE482=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5519);  
 20466  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE482);
 20467  
 
 20468  1
 
 20469  
                     // AST REWRITE
 20470  1
                     // elements: expression, expression, STRBEFORE
 20471  
                     // token labels: 
 20472  
                     // rule labels: retval
 20473  
                     // token list labels: 
 20474  
                     // rule list labels: 
 20475  
                     // wildcard labels: 
 20476  2
                     retval.tree = root_0;
 20477  1
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20478  
 
 20479  2
                     root_0 = (Object)adaptor.nil();
 20480  
                     // 563:68: -> ^( STRBEFORE expression expression )
 20481  
                     {
 20482  
                         // com\\googlecode\\sparkleg\\Sparql.g:563:71: ^( STRBEFORE expression expression )
 20483  1
                         {
 20484  2
                         Object root_1 = (Object)adaptor.nil();
 20485  1
                         root_1 = (Object)adaptor.becomeRoot(
 20486  
                         stream_STRBEFORE.nextNode()
 20487  1
                         , root_1);
 20488  1
 
 20489  1
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20490  
 
 20491  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20492  1
 
 20493  1
                         adaptor.addChild(root_0, root_1);
 20494  1
                         }
 20495  
 
 20496  1
                     }
 20497  
 
 20498  1
 
 20499  2
                     retval.tree = root_0;
 20500  
 
 20501  
                     }
 20502  2
                     break;
 20503  1
                 case 25 :
 20504  
                     // com\\googlecode\\sparkleg\\Sparql.g:564:7: STRAFTER OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20505  1
                     {
 20506  1
                     STRAFTER483=(Token)match(input,STRAFTER,FOLLOW_STRAFTER_in_builtInCall5537);  
 20507  2
                     stream_STRAFTER.add(STRAFTER483);
 20508  
 
 20509  1
 
 20510  2
                     OPEN_BRACE484=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5539);  
 20511  1
                     stream_OPEN_BRACE.add(OPEN_BRACE484);
 20512  
 
 20513  
 
 20514  1
                     pushFollow(FOLLOW_expression_in_builtInCall5541);
 20515  1
                     expression485=expression();
 20516  
 
 20517  1
                     state._fsp--;
 20518  
 
 20519  1
                     stream_expression.add(expression485.getTree());
 20520  1
 
 20521  2
                     COMMA486=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5543);  
 20522  1
                     stream_COMMA.add(COMMA486);
 20523  1
 
 20524  
 
 20525  1
                     pushFollow(FOLLOW_expression_in_builtInCall5545);
 20526  1
                     expression487=expression();
 20527  
 
 20528  2
                     state._fsp--;
 20529  1
 
 20530  1
                     stream_expression.add(expression487.getTree());
 20531  
 
 20532  1
                     CLOSE_BRACE488=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5547);  
 20533  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE488);
 20534  
 
 20535  1
 
 20536  
                     // AST REWRITE
 20537  1
                     // elements: expression, expression, STRAFTER
 20538  
                     // token labels: 
 20539  
                     // rule labels: retval
 20540  
                     // token list labels: 
 20541  
                     // rule list labels: 
 20542  
                     // wildcard labels: 
 20543  2
                     retval.tree = root_0;
 20544  1
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20545  
 
 20546  2
                     root_0 = (Object)adaptor.nil();
 20547  
                     // 564:67: -> ^( STRAFTER expression expression )
 20548  
                     {
 20549  
                         // com\\googlecode\\sparkleg\\Sparql.g:564:70: ^( STRAFTER expression expression )
 20550  3
                         {
 20551  4
                         Object root_1 = (Object)adaptor.nil();
 20552  1
                         root_1 = (Object)adaptor.becomeRoot(
 20553  
                         stream_STRAFTER.nextNode()
 20554  3
                         , root_1);
 20555  3
 
 20556  1
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20557  
 
 20558  4
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20559  3
 
 20560  1
                         adaptor.addChild(root_0, root_1);
 20561  3
                         }
 20562  
 
 20563  3
                     }
 20564  
 
 20565  3
 
 20566  4
                     retval.tree = root_0;
 20567  
 
 20568  
                     }
 20569  4
                     break;
 20570  3
                 case 26 :
 20571  
                     // com\\googlecode\\sparkleg\\Sparql.g:565:7: REPLACE OPEN_BRACE expression COMMA expression COMMA expression CLOSE_BRACE
 20572  3
                     {
 20573  3
                     REPLACE489=(Token)match(input,REPLACE,FOLLOW_REPLACE_in_builtInCall5565);  
 20574  6
                     stream_REPLACE.add(REPLACE489);
 20575  
 
 20576  3
 
 20577  6
                     OPEN_BRACE490=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5567);  
 20578  3
                     stream_OPEN_BRACE.add(OPEN_BRACE490);
 20579  
 
 20580  3
 
 20581  6
                     pushFollow(FOLLOW_expression_in_builtInCall5569);
 20582  3
                     expression491=expression();
 20583  3
 
 20584  3
                     state._fsp--;
 20585  3
 
 20586  3
                     stream_expression.add(expression491.getTree());
 20587  3
 
 20588  6
                     COMMA492=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5571);  
 20589  3
                     stream_COMMA.add(COMMA492);
 20590  
 
 20591  
 
 20592  3
                     pushFollow(FOLLOW_expression_in_builtInCall5573);
 20593  3
                     expression493=expression();
 20594  
 
 20595  3
                     state._fsp--;
 20596  
 
 20597  3
                     stream_expression.add(expression493.getTree());
 20598  3
 
 20599  6
                     COMMA494=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5575);  
 20600  3
                     stream_COMMA.add(COMMA494);
 20601  3
 
 20602  
 
 20603  3
                     pushFollow(FOLLOW_expression_in_builtInCall5577);
 20604  3
                     expression495=expression();
 20605  
 
 20606  6
                     state._fsp--;
 20607  3
 
 20608  3
                     stream_expression.add(expression495.getTree());
 20609  
 
 20610  3
                     CLOSE_BRACE496=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5579);  
 20611  6
                     stream_CLOSE_BRACE.add(CLOSE_BRACE496);
 20612  
 
 20613  3
 
 20614  
                     // AST REWRITE
 20615  3
                     // elements: expression, expression, REPLACE, expression
 20616  
                     // token labels: 
 20617  3
                     // rule labels: retval
 20618  
                     // token list labels: 
 20619  
                     // rule list labels: 
 20620  
                     // wildcard labels: 
 20621  3
                     retval.tree = root_0;
 20622  3
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20623  3
 
 20624  3
                     root_0 = (Object)adaptor.nil();
 20625  
                     // 565:83: -> ^( REPLACE expression expression expression )
 20626  3
                     {
 20627  
                         // com\\googlecode\\sparkleg\\Sparql.g:565:86: ^( REPLACE expression expression expression )
 20628  
                         {
 20629  3
                         Object root_1 = (Object)adaptor.nil();
 20630  4
                         root_1 = (Object)adaptor.becomeRoot(
 20631  1
                         stream_REPLACE.nextNode()
 20632  
                         , root_1);
 20633  
 
 20634  4
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20635  1
 
 20636  3
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20637  
 
 20638  4
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20639  1
 
 20640  3
                         adaptor.addChild(root_0, root_1);
 20641  1
                         }
 20642  
 
 20643  1
                     }
 20644  
 
 20645  1
 
 20646  4
                     retval.tree = root_0;
 20647  
 
 20648  
                     }
 20649  3
                     break;
 20650  
                 case 27 :
 20651  
                     // com\\googlecode\\sparkleg\\Sparql.g:566:7: YEAR OPEN_BRACE expression CLOSE_BRACE
 20652  
                     {
 20653  1
                     YEAR497=(Token)match(input,YEAR,FOLLOW_YEAR_in_builtInCall5599);  
 20654  1
                     stream_YEAR.add(YEAR497);
 20655  
 
 20656  1
 
 20657  2
                     OPEN_BRACE498=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5601);  
 20658  1
                     stream_OPEN_BRACE.add(OPEN_BRACE498);
 20659  1
 
 20660  
 
 20661  1
                     pushFollow(FOLLOW_expression_in_builtInCall5603);
 20662  1
                     expression499=expression();
 20663  
 
 20664  2
                     state._fsp--;
 20665  1
 
 20666  1
                     stream_expression.add(expression499.getTree());
 20667  
 
 20668  1
                     CLOSE_BRACE500=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5605);  
 20669  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE500);
 20670  
 
 20671  1
 
 20672  
                     // AST REWRITE
 20673  
                     // elements: YEAR, expression
 20674  
                     // token labels: 
 20675  
                     // rule labels: retval
 20676  
                     // token list labels: 
 20677  1
                     // rule list labels: 
 20678  
                     // wildcard labels: 
 20679  1
                     retval.tree = root_0;
 20680  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20681  
 
 20682  1
                     root_0 = (Object)adaptor.nil();
 20683  
                     // 566:46: -> ^( YEAR expression )
 20684  1
                     {
 20685  1
                         // com\\googlecode\\sparkleg\\Sparql.g:566:49: ^( YEAR expression )
 20686  
                         {
 20687  1
                         Object root_1 = (Object)adaptor.nil();
 20688  2
                         root_1 = (Object)adaptor.becomeRoot(
 20689  1
                         stream_YEAR.nextNode()
 20690  
                         , root_1);
 20691  
 
 20692  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20693  1
 
 20694  1
                         adaptor.addChild(root_0, root_1);
 20695  1
                         }
 20696  
 
 20697  1
                     }
 20698  
 
 20699  1
 
 20700  2
                     retval.tree = root_0;
 20701  
 
 20702  
                     }
 20703  1
                     break;
 20704  
                 case 28 :
 20705  
                     // com\\googlecode\\sparkleg\\Sparql.g:567:7: MONTH OPEN_BRACE expression CLOSE_BRACE
 20706  
                     {
 20707  1
                     MONTH501=(Token)match(input,MONTH,FOLLOW_MONTH_in_builtInCall5621);  
 20708  1
                     stream_MONTH.add(MONTH501);
 20709  
 
 20710  1
 
 20711  2
                     OPEN_BRACE502=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5623);  
 20712  1
                     stream_OPEN_BRACE.add(OPEN_BRACE502);
 20713  1
 
 20714  
 
 20715  1
                     pushFollow(FOLLOW_expression_in_builtInCall5625);
 20716  1
                     expression503=expression();
 20717  
 
 20718  2
                     state._fsp--;
 20719  1
 
 20720  1
                     stream_expression.add(expression503.getTree());
 20721  
 
 20722  1
                     CLOSE_BRACE504=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5627);  
 20723  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE504);
 20724  
 
 20725  1
 
 20726  
                     // AST REWRITE
 20727  
                     // elements: MONTH, expression
 20728  
                     // token labels: 
 20729  
                     // rule labels: retval
 20730  
                     // token list labels: 
 20731  1
                     // rule list labels: 
 20732  
                     // wildcard labels: 
 20733  1
                     retval.tree = root_0;
 20734  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20735  
 
 20736  1
                     root_0 = (Object)adaptor.nil();
 20737  
                     // 567:47: -> ^( MONTH expression )
 20738  1
                     {
 20739  1
                         // com\\googlecode\\sparkleg\\Sparql.g:567:50: ^( MONTH expression )
 20740  
                         {
 20741  1
                         Object root_1 = (Object)adaptor.nil();
 20742  2
                         root_1 = (Object)adaptor.becomeRoot(
 20743  1
                         stream_MONTH.nextNode()
 20744  
                         , root_1);
 20745  
 
 20746  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20747  1
 
 20748  1
                         adaptor.addChild(root_0, root_1);
 20749  1
                         }
 20750  
 
 20751  1
                     }
 20752  
 
 20753  1
 
 20754  2
                     retval.tree = root_0;
 20755  
 
 20756  
                     }
 20757  1
                     break;
 20758  
                 case 29 :
 20759  
                     // com\\googlecode\\sparkleg\\Sparql.g:568:7: DAY OPEN_BRACE expression CLOSE_BRACE
 20760  
                     {
 20761  1
                     DAY505=(Token)match(input,DAY,FOLLOW_DAY_in_builtInCall5643);  
 20762  1
                     stream_DAY.add(DAY505);
 20763  
 
 20764  1
 
 20765  2
                     OPEN_BRACE506=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5645);  
 20766  1
                     stream_OPEN_BRACE.add(OPEN_BRACE506);
 20767  1
 
 20768  
 
 20769  1
                     pushFollow(FOLLOW_expression_in_builtInCall5647);
 20770  1
                     expression507=expression();
 20771  
 
 20772  2
                     state._fsp--;
 20773  1
 
 20774  1
                     stream_expression.add(expression507.getTree());
 20775  
 
 20776  1
                     CLOSE_BRACE508=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5649);  
 20777  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE508);
 20778  
 
 20779  1
 
 20780  
                     // AST REWRITE
 20781  
                     // elements: DAY, expression
 20782  
                     // token labels: 
 20783  
                     // rule labels: retval
 20784  
                     // token list labels: 
 20785  1
                     // rule list labels: 
 20786  
                     // wildcard labels: 
 20787  1
                     retval.tree = root_0;
 20788  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20789  
 
 20790  1
                     root_0 = (Object)adaptor.nil();
 20791  
                     // 568:45: -> ^( DAY expression )
 20792  1
                     {
 20793  1
                         // com\\googlecode\\sparkleg\\Sparql.g:568:48: ^( DAY expression )
 20794  
                         {
 20795  1
                         Object root_1 = (Object)adaptor.nil();
 20796  2
                         root_1 = (Object)adaptor.becomeRoot(
 20797  1
                         stream_DAY.nextNode()
 20798  
                         , root_1);
 20799  
 
 20800  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20801  1
 
 20802  1
                         adaptor.addChild(root_0, root_1);
 20803  1
                         }
 20804  
 
 20805  1
                     }
 20806  
 
 20807  1
 
 20808  2
                     retval.tree = root_0;
 20809  
 
 20810  
                     }
 20811  1
                     break;
 20812  
                 case 30 :
 20813  
                     // com\\googlecode\\sparkleg\\Sparql.g:569:7: HOURS OPEN_BRACE expression CLOSE_BRACE
 20814  
                     {
 20815  1
                     HOURS509=(Token)match(input,HOURS,FOLLOW_HOURS_in_builtInCall5665);  
 20816  1
                     stream_HOURS.add(HOURS509);
 20817  
 
 20818  1
 
 20819  2
                     OPEN_BRACE510=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5667);  
 20820  1
                     stream_OPEN_BRACE.add(OPEN_BRACE510);
 20821  1
 
 20822  
 
 20823  1
                     pushFollow(FOLLOW_expression_in_builtInCall5669);
 20824  1
                     expression511=expression();
 20825  
 
 20826  2
                     state._fsp--;
 20827  1
 
 20828  1
                     stream_expression.add(expression511.getTree());
 20829  
 
 20830  1
                     CLOSE_BRACE512=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5671);  
 20831  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE512);
 20832  
 
 20833  1
 
 20834  
                     // AST REWRITE
 20835  
                     // elements: expression, HOURS
 20836  
                     // token labels: 
 20837  
                     // rule labels: retval
 20838  
                     // token list labels: 
 20839  1
                     // rule list labels: 
 20840  
                     // wildcard labels: 
 20841  1
                     retval.tree = root_0;
 20842  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20843  
 
 20844  1
                     root_0 = (Object)adaptor.nil();
 20845  
                     // 569:47: -> ^( HOURS expression )
 20846  1
                     {
 20847  1
                         // com\\googlecode\\sparkleg\\Sparql.g:569:50: ^( HOURS expression )
 20848  
                         {
 20849  1
                         Object root_1 = (Object)adaptor.nil();
 20850  2
                         root_1 = (Object)adaptor.becomeRoot(
 20851  1
                         stream_HOURS.nextNode()
 20852  
                         , root_1);
 20853  
 
 20854  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20855  1
 
 20856  1
                         adaptor.addChild(root_0, root_1);
 20857  1
                         }
 20858  
 
 20859  1
                     }
 20860  
 
 20861  1
 
 20862  2
                     retval.tree = root_0;
 20863  
 
 20864  
                     }
 20865  1
                     break;
 20866  
                 case 31 :
 20867  
                     // com\\googlecode\\sparkleg\\Sparql.g:570:7: MINUTES OPEN_BRACE expression CLOSE_BRACE
 20868  
                     {
 20869  1
                     MINUTES513=(Token)match(input,MINUTES,FOLLOW_MINUTES_in_builtInCall5687);  
 20870  1
                     stream_MINUTES.add(MINUTES513);
 20871  
 
 20872  1
 
 20873  2
                     OPEN_BRACE514=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5689);  
 20874  1
                     stream_OPEN_BRACE.add(OPEN_BRACE514);
 20875  1
 
 20876  
 
 20877  1
                     pushFollow(FOLLOW_expression_in_builtInCall5691);
 20878  1
                     expression515=expression();
 20879  
 
 20880  2
                     state._fsp--;
 20881  1
 
 20882  1
                     stream_expression.add(expression515.getTree());
 20883  
 
 20884  1
                     CLOSE_BRACE516=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5693);  
 20885  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE516);
 20886  
 
 20887  1
 
 20888  
                     // AST REWRITE
 20889  
                     // elements: expression, MINUTES
 20890  
                     // token labels: 
 20891  
                     // rule labels: retval
 20892  
                     // token list labels: 
 20893  1
                     // rule list labels: 
 20894  
                     // wildcard labels: 
 20895  1
                     retval.tree = root_0;
 20896  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20897  
 
 20898  1
                     root_0 = (Object)adaptor.nil();
 20899  
                     // 570:49: -> ^( MINUTES expression )
 20900  1
                     {
 20901  1
                         // com\\googlecode\\sparkleg\\Sparql.g:570:52: ^( MINUTES expression )
 20902  
                         {
 20903  1
                         Object root_1 = (Object)adaptor.nil();
 20904  2
                         root_1 = (Object)adaptor.becomeRoot(
 20905  1
                         stream_MINUTES.nextNode()
 20906  
                         , root_1);
 20907  
 
 20908  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20909  1
 
 20910  1
                         adaptor.addChild(root_0, root_1);
 20911  1
                         }
 20912  
 
 20913  1
                     }
 20914  
 
 20915  1
 
 20916  2
                     retval.tree = root_0;
 20917  
 
 20918  
                     }
 20919  1
                     break;
 20920  
                 case 32 :
 20921  
                     // com\\googlecode\\sparkleg\\Sparql.g:571:7: SECONDS OPEN_BRACE expression CLOSE_BRACE
 20922  
                     {
 20923  1
                     SECONDS517=(Token)match(input,SECONDS,FOLLOW_SECONDS_in_builtInCall5709);  
 20924  1
                     stream_SECONDS.add(SECONDS517);
 20925  
 
 20926  1
 
 20927  2
                     OPEN_BRACE518=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5711);  
 20928  1
                     stream_OPEN_BRACE.add(OPEN_BRACE518);
 20929  1
 
 20930  
 
 20931  1
                     pushFollow(FOLLOW_expression_in_builtInCall5713);
 20932  1
                     expression519=expression();
 20933  
 
 20934  2
                     state._fsp--;
 20935  1
 
 20936  1
                     stream_expression.add(expression519.getTree());
 20937  
 
 20938  1
                     CLOSE_BRACE520=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5715);  
 20939  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE520);
 20940  
 
 20941  1
 
 20942  
                     // AST REWRITE
 20943  
                     // elements: SECONDS, expression
 20944  
                     // token labels: 
 20945  
                     // rule labels: retval
 20946  
                     // token list labels: 
 20947  1
                     // rule list labels: 
 20948  
                     // wildcard labels: 
 20949  1
                     retval.tree = root_0;
 20950  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20951  
 
 20952  1
                     root_0 = (Object)adaptor.nil();
 20953  
                     // 571:49: -> ^( SECONDS expression )
 20954  1
                     {
 20955  1
                         // com\\googlecode\\sparkleg\\Sparql.g:571:52: ^( SECONDS expression )
 20956  
                         {
 20957  1
                         Object root_1 = (Object)adaptor.nil();
 20958  2
                         root_1 = (Object)adaptor.becomeRoot(
 20959  1
                         stream_SECONDS.nextNode()
 20960  
                         , root_1);
 20961  
 
 20962  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20963  1
 
 20964  1
                         adaptor.addChild(root_0, root_1);
 20965  1
                         }
 20966  
 
 20967  1
                     }
 20968  
 
 20969  1
 
 20970  2
                     retval.tree = root_0;
 20971  
 
 20972  
                     }
 20973  1
                     break;
 20974  
                 case 33 :
 20975  
                     // com\\googlecode\\sparkleg\\Sparql.g:572:7: TIMEZONE OPEN_BRACE expression CLOSE_BRACE
 20976  
                     {
 20977  1
                     TIMEZONE521=(Token)match(input,TIMEZONE,FOLLOW_TIMEZONE_in_builtInCall5731);  
 20978  1
                     stream_TIMEZONE.add(TIMEZONE521);
 20979  
 
 20980  1
 
 20981  2
                     OPEN_BRACE522=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5733);  
 20982  1
                     stream_OPEN_BRACE.add(OPEN_BRACE522);
 20983  1
 
 20984  
 
 20985  1
                     pushFollow(FOLLOW_expression_in_builtInCall5735);
 20986  1
                     expression523=expression();
 20987  
 
 20988  2
                     state._fsp--;
 20989  1
 
 20990  1
                     stream_expression.add(expression523.getTree());
 20991  
 
 20992  1
                     CLOSE_BRACE524=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5737);  
 20993  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE524);
 20994  
 
 20995  1
 
 20996  
                     // AST REWRITE
 20997  
                     // elements: expression, TIMEZONE
 20998  
                     // token labels: 
 20999  
                     // rule labels: retval
 21000  
                     // token list labels: 
 21001  1
                     // rule list labels: 
 21002  
                     // wildcard labels: 
 21003  1
                     retval.tree = root_0;
 21004  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21005  
 
 21006  1
                     root_0 = (Object)adaptor.nil();
 21007  
                     // 572:50: -> ^( TIMEZONE expression )
 21008  1
                     {
 21009  1
                         // com\\googlecode\\sparkleg\\Sparql.g:572:53: ^( TIMEZONE expression )
 21010  
                         {
 21011  1
                         Object root_1 = (Object)adaptor.nil();
 21012  2
                         root_1 = (Object)adaptor.becomeRoot(
 21013  1
                         stream_TIMEZONE.nextNode()
 21014  
                         , root_1);
 21015  
 
 21016  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21017  1
 
 21018  1
                         adaptor.addChild(root_0, root_1);
 21019  1
                         }
 21020  
 
 21021  1
                     }
 21022  
 
 21023  1
 
 21024  2
                     retval.tree = root_0;
 21025  
 
 21026  
                     }
 21027  1
                     break;
 21028  
                 case 34 :
 21029  
                     // com\\googlecode\\sparkleg\\Sparql.g:573:7: TZ OPEN_BRACE expression CLOSE_BRACE
 21030  
                     {
 21031  1
                     TZ525=(Token)match(input,TZ,FOLLOW_TZ_in_builtInCall5753);  
 21032  1
                     stream_TZ.add(TZ525);
 21033  
 
 21034  1
 
 21035  2
                     OPEN_BRACE526=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5755);  
 21036  1
                     stream_OPEN_BRACE.add(OPEN_BRACE526);
 21037  1
 
 21038  
 
 21039  1
                     pushFollow(FOLLOW_expression_in_builtInCall5757);
 21040  1
                     expression527=expression();
 21041  
 
 21042  2
                     state._fsp--;
 21043  1
 
 21044  1
                     stream_expression.add(expression527.getTree());
 21045  
 
 21046  1
                     CLOSE_BRACE528=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5759);  
 21047  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE528);
 21048  
 
 21049  1
 
 21050  
                     // AST REWRITE
 21051  
                     // elements: expression, TZ
 21052  
                     // token labels: 
 21053  
                     // rule labels: retval
 21054  
                     // token list labels: 
 21055  1
                     // rule list labels: 
 21056  
                     // wildcard labels: 
 21057  1
                     retval.tree = root_0;
 21058  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21059  
 
 21060  1
                     root_0 = (Object)adaptor.nil();
 21061  
                     // 573:44: -> ^( TZ expression )
 21062  1
                     {
 21063  1
                         // com\\googlecode\\sparkleg\\Sparql.g:573:47: ^( TZ expression )
 21064  
                         {
 21065  1
                         Object root_1 = (Object)adaptor.nil();
 21066  2
                         root_1 = (Object)adaptor.becomeRoot(
 21067  1
                         stream_TZ.nextNode()
 21068  
                         , root_1);
 21069  1
 
 21070  1
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21071  1
 
 21072  1
                         adaptor.addChild(root_0, root_1);
 21073  
                         }
 21074  
 
 21075  
                     }
 21076  
 
 21077  
 
 21078  1
                     retval.tree = root_0;
 21079  
 
 21080  1
                     }
 21081  2
                     break;
 21082  
                 case 35 :
 21083  1
                     // com\\googlecode\\sparkleg\\Sparql.g:574:7: NOW nil
 21084  
                     {
 21085  1
                     NOW529=(Token)match(input,NOW,FOLLOW_NOW_in_builtInCall5775);  
 21086  2
                     stream_NOW.add(NOW529);
 21087  
 
 21088  
 
 21089  1
                     pushFollow(FOLLOW_nil_in_builtInCall5777);
 21090  1
                     nil530=nil();
 21091  
 
 21092  1
                     state._fsp--;
 21093  1
 
 21094  1
                     stream_nil.add(nil530.getTree());
 21095  
 
 21096  1
                     // AST REWRITE
 21097  
                     // elements: NOW
 21098  
                     // token labels: 
 21099  
                     // rule labels: retval
 21100  2
                     // token list labels: 
 21101  2
                     // rule list labels: 
 21102  
                     // wildcard labels: 
 21103  1
                     retval.tree = root_0;
 21104  3
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21105  2
 
 21106  1
                     root_0 = (Object)adaptor.nil();
 21107  
                     // 574:15: -> NOW
 21108  2
                     {
 21109  3
                         adaptor.addChild(root_0, 
 21110  
                         stream_NOW.nextNode()
 21111  2
                         );
 21112  
 
 21113  2
                     }
 21114  
 
 21115  2
 
 21116  3
                     retval.tree = root_0;
 21117  
 
 21118  
                     }
 21119  1
                     break;
 21120  
                 case 36 :
 21121  
                     // com\\googlecode\\sparkleg\\Sparql.g:575:7: MD5 OPEN_BRACE expression CLOSE_BRACE
 21122  
                     {
 21123  2
                     MD5531=(Token)match(input,MD5,FOLLOW_MD5_in_builtInCall5789);  
 21124  2
                     stream_MD5.add(MD5531);
 21125  
 
 21126  2
 
 21127  4
                     OPEN_BRACE532=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5791);  
 21128  2
                     stream_OPEN_BRACE.add(OPEN_BRACE532);
 21129  2
 
 21130  
 
 21131  2
                     pushFollow(FOLLOW_expression_in_builtInCall5793);
 21132  2
                     expression533=expression();
 21133  
 
 21134  4
                     state._fsp--;
 21135  2
 
 21136  2
                     stream_expression.add(expression533.getTree());
 21137  
 
 21138  2
                     CLOSE_BRACE534=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5795);  
 21139  4
                     stream_CLOSE_BRACE.add(CLOSE_BRACE534);
 21140  
 
 21141  2
 
 21142  
                     // AST REWRITE
 21143  
                     // elements: MD5, expression
 21144  
                     // token labels: 
 21145  
                     // rule labels: retval
 21146  
                     // token list labels: 
 21147  2
                     // rule list labels: 
 21148  
                     // wildcard labels: 
 21149  2
                     retval.tree = root_0;
 21150  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21151  
 
 21152  2
                     root_0 = (Object)adaptor.nil();
 21153  
                     // 575:45: -> ^( MD5 expression )
 21154  2
                     {
 21155  2
                         // com\\googlecode\\sparkleg\\Sparql.g:575:48: ^( MD5 expression )
 21156  
                         {
 21157  2
                         Object root_1 = (Object)adaptor.nil();
 21158  4
                         root_1 = (Object)adaptor.becomeRoot(
 21159  2
                         stream_MD5.nextNode()
 21160  
                         , root_1);
 21161  
 
 21162  4
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21163  2
 
 21164  2
                         adaptor.addChild(root_0, root_1);
 21165  2
                         }
 21166  
 
 21167  2
                     }
 21168  
 
 21169  2
 
 21170  4
                     retval.tree = root_0;
 21171  
 
 21172  
                     }
 21173  2
                     break;
 21174  
                 case 37 :
 21175  
                     // com\\googlecode\\sparkleg\\Sparql.g:576:7: SHA1 OPEN_BRACE expression CLOSE_BRACE
 21176  
                     {
 21177  2
                     SHA1535=(Token)match(input,SHA1,FOLLOW_SHA1_in_builtInCall5811);  
 21178  2
                     stream_SHA1.add(SHA1535);
 21179  
 
 21180  2
 
 21181  4
                     OPEN_BRACE536=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5813);  
 21182  2
                     stream_OPEN_BRACE.add(OPEN_BRACE536);
 21183  2
 
 21184  
 
 21185  2
                     pushFollow(FOLLOW_expression_in_builtInCall5815);
 21186  2
                     expression537=expression();
 21187  
 
 21188  4
                     state._fsp--;
 21189  2
 
 21190  2
                     stream_expression.add(expression537.getTree());
 21191  
 
 21192  2
                     CLOSE_BRACE538=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5817);  
 21193  4
                     stream_CLOSE_BRACE.add(CLOSE_BRACE538);
 21194  
 
 21195  2
 
 21196  
                     // AST REWRITE
 21197  
                     // elements: expression, SHA1
 21198  
                     // token labels: 
 21199  
                     // rule labels: retval
 21200  
                     // token list labels: 
 21201  2
                     // rule list labels: 
 21202  
                     // wildcard labels: 
 21203  2
                     retval.tree = root_0;
 21204  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21205  
 
 21206  2
                     root_0 = (Object)adaptor.nil();
 21207  
                     // 576:46: -> ^( SHA1 expression )
 21208  
                     {
 21209  
                         // com\\googlecode\\sparkleg\\Sparql.g:576:49: ^( SHA1 expression )
 21210  
                         {
 21211  2
                         Object root_1 = (Object)adaptor.nil();
 21212  2
                         root_1 = (Object)adaptor.becomeRoot(
 21213  
                         stream_SHA1.nextNode()
 21214  
                         , root_1);
 21215  
 
 21216  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21217  
 
 21218  2
                         adaptor.addChild(root_0, root_1);
 21219  
                         }
 21220  
 
 21221  
                     }
 21222  
 
 21223  
 
 21224  2
                     retval.tree = root_0;
 21225  
 
 21226  
                     }
 21227  2
                     break;
 21228  
                 case 38 :
 21229  
                     // com\\googlecode\\sparkleg\\Sparql.g:577:7: SHA224 OPEN_BRACE expression CLOSE_BRACE
 21230  
                     {
 21231  0
                     SHA224539=(Token)match(input,SHA224,FOLLOW_SHA224_in_builtInCall5833);  
 21232  0
                     stream_SHA224.add(SHA224539);
 21233  
 
 21234  
 
 21235  0
                     OPEN_BRACE540=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5835);  
 21236  0
                     stream_OPEN_BRACE.add(OPEN_BRACE540);
 21237  
 
 21238  
 
 21239  0
                     pushFollow(FOLLOW_expression_in_builtInCall5837);
 21240  0
                     expression541=expression();
 21241  
 
 21242  0
                     state._fsp--;
 21243  
 
 21244  0
                     stream_expression.add(expression541.getTree());
 21245  
 
 21246  0
                     CLOSE_BRACE542=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5839);  
 21247  0
                     stream_CLOSE_BRACE.add(CLOSE_BRACE542);
 21248  
 
 21249  
 
 21250  
                     // AST REWRITE
 21251  
                     // elements: expression, SHA224
 21252  
                     // token labels: 
 21253  
                     // rule labels: retval
 21254  
                     // token list labels: 
 21255  
                     // rule list labels: 
 21256  
                     // wildcard labels: 
 21257  0
                     retval.tree = root_0;
 21258  0
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21259  
 
 21260  0
                     root_0 = (Object)adaptor.nil();
 21261  
                     // 577:48: -> ^( SHA224 expression )
 21262  2
                     {
 21263  2
                         // com\\googlecode\\sparkleg\\Sparql.g:577:51: ^( SHA224 expression )
 21264  
                         {
 21265  0
                         Object root_1 = (Object)adaptor.nil();
 21266  2
                         root_1 = (Object)adaptor.becomeRoot(
 21267  2
                         stream_SHA224.nextNode()
 21268  
                         , root_1);
 21269  
 
 21270  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21271  2
 
 21272  0
                         adaptor.addChild(root_0, root_1);
 21273  2
                         }
 21274  
 
 21275  2
                     }
 21276  
 
 21277  2
 
 21278  2
                     retval.tree = root_0;
 21279  
 
 21280  
                     }
 21281  0
                     break;
 21282  
                 case 39 :
 21283  
                     // com\\googlecode\\sparkleg\\Sparql.g:578:7: SHA256 OPEN_BRACE expression CLOSE_BRACE
 21284  
                     {
 21285  2
                     SHA256543=(Token)match(input,SHA256,FOLLOW_SHA256_in_builtInCall5855);  
 21286  2
                     stream_SHA256.add(SHA256543);
 21287  
 
 21288  2
 
 21289  4
                     OPEN_BRACE544=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5857);  
 21290  2
                     stream_OPEN_BRACE.add(OPEN_BRACE544);
 21291  2
 
 21292  
 
 21293  2
                     pushFollow(FOLLOW_expression_in_builtInCall5859);
 21294  2
                     expression545=expression();
 21295  
 
 21296  4
                     state._fsp--;
 21297  2
 
 21298  2
                     stream_expression.add(expression545.getTree());
 21299  
 
 21300  2
                     CLOSE_BRACE546=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5861);  
 21301  4
                     stream_CLOSE_BRACE.add(CLOSE_BRACE546);
 21302  
 
 21303  2
 
 21304  
                     // AST REWRITE
 21305  
                     // elements: SHA256, expression
 21306  
                     // token labels: 
 21307  
                     // rule labels: retval
 21308  
                     // token list labels: 
 21309  2
                     // rule list labels: 
 21310  
                     // wildcard labels: 
 21311  2
                     retval.tree = root_0;
 21312  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21313  
 
 21314  2
                     root_0 = (Object)adaptor.nil();
 21315  
                     // 578:48: -> ^( SHA256 expression )
 21316  2
                     {
 21317  2
                         // com\\googlecode\\sparkleg\\Sparql.g:578:51: ^( SHA256 expression )
 21318  
                         {
 21319  2
                         Object root_1 = (Object)adaptor.nil();
 21320  4
                         root_1 = (Object)adaptor.becomeRoot(
 21321  2
                         stream_SHA256.nextNode()
 21322  
                         , root_1);
 21323  
 
 21324  4
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21325  2
 
 21326  2
                         adaptor.addChild(root_0, root_1);
 21327  2
                         }
 21328  
 
 21329  2
                     }
 21330  
 
 21331  2
 
 21332  4
                     retval.tree = root_0;
 21333  
 
 21334  
                     }
 21335  2
                     break;
 21336  
                 case 40 :
 21337  
                     // com\\googlecode\\sparkleg\\Sparql.g:579:7: SHA384 OPEN_BRACE expression CLOSE_BRACE
 21338  
                     {
 21339  2
                     SHA384547=(Token)match(input,SHA384,FOLLOW_SHA384_in_builtInCall5877);  
 21340  2
                     stream_SHA384.add(SHA384547);
 21341  
 
 21342  2
 
 21343  4
                     OPEN_BRACE548=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5879);  
 21344  2
                     stream_OPEN_BRACE.add(OPEN_BRACE548);
 21345  2
 
 21346  
 
 21347  2
                     pushFollow(FOLLOW_expression_in_builtInCall5881);
 21348  2
                     expression549=expression();
 21349  
 
 21350  4
                     state._fsp--;
 21351  2
 
 21352  2
                     stream_expression.add(expression549.getTree());
 21353  
 
 21354  2
                     CLOSE_BRACE550=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5883);  
 21355  4
                     stream_CLOSE_BRACE.add(CLOSE_BRACE550);
 21356  
 
 21357  2
 
 21358  
                     // AST REWRITE
 21359  
                     // elements: expression, SHA384
 21360  
                     // token labels: 
 21361  
                     // rule labels: retval
 21362  
                     // token list labels: 
 21363  2
                     // rule list labels: 
 21364  
                     // wildcard labels: 
 21365  2
                     retval.tree = root_0;
 21366  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21367  
 
 21368  2
                     root_0 = (Object)adaptor.nil();
 21369  
                     // 579:48: -> ^( SHA384 expression )
 21370  2
                     {
 21371  2
                         // com\\googlecode\\sparkleg\\Sparql.g:579:51: ^( SHA384 expression )
 21372  
                         {
 21373  2
                         Object root_1 = (Object)adaptor.nil();
 21374  4
                         root_1 = (Object)adaptor.becomeRoot(
 21375  2
                         stream_SHA384.nextNode()
 21376  
                         , root_1);
 21377  
 
 21378  4
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21379  2
 
 21380  2
                         adaptor.addChild(root_0, root_1);
 21381  2
                         }
 21382  
 
 21383  2
                     }
 21384  
 
 21385  2
 
 21386  4
                     retval.tree = root_0;
 21387  
 
 21388  
                     }
 21389  2
                     break;
 21390  
                 case 41 :
 21391  
                     // com\\googlecode\\sparkleg\\Sparql.g:580:7: SHA512 OPEN_BRACE expression CLOSE_BRACE
 21392  
                     {
 21393  2
                     SHA512551=(Token)match(input,SHA512,FOLLOW_SHA512_in_builtInCall5899);  
 21394  2
                     stream_SHA512.add(SHA512551);
 21395  
 
 21396  2
 
 21397  4
                     OPEN_BRACE552=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5901);  
 21398  2
                     stream_OPEN_BRACE.add(OPEN_BRACE552);
 21399  2
 
 21400  
 
 21401  2
                     pushFollow(FOLLOW_expression_in_builtInCall5903);
 21402  2
                     expression553=expression();
 21403  
 
 21404  4
                     state._fsp--;
 21405  2
 
 21406  2
                     stream_expression.add(expression553.getTree());
 21407  
 
 21408  2
                     CLOSE_BRACE554=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5905);  
 21409  4
                     stream_CLOSE_BRACE.add(CLOSE_BRACE554);
 21410  
 
 21411  2
 
 21412  
                     // AST REWRITE
 21413  
                     // elements: SHA512, expression
 21414  
                     // token labels: 
 21415  
                     // rule labels: retval
 21416  
                     // token list labels: 
 21417  2
                     // rule list labels: 
 21418  
                     // wildcard labels: 
 21419  2
                     retval.tree = root_0;
 21420  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21421  
 
 21422  2
                     root_0 = (Object)adaptor.nil();
 21423  
                     // 580:48: -> ^( SHA512 expression )
 21424  6
                     {
 21425  6
                         // com\\googlecode\\sparkleg\\Sparql.g:580:51: ^( SHA512 expression )
 21426  
                         {
 21427  2
                         Object root_1 = (Object)adaptor.nil();
 21428  8
                         root_1 = (Object)adaptor.becomeRoot(
 21429  6
                         stream_SHA512.nextNode()
 21430  
                         , root_1);
 21431  6
 
 21432  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21433  6
 
 21434  2
                         adaptor.addChild(root_0, root_1);
 21435  
                         }
 21436  
 
 21437  
                     }
 21438  
 
 21439  
 
 21440  2
                     retval.tree = root_0;
 21441  
 
 21442  6
                     }
 21443  8
                     break;
 21444  
                 case 42 :
 21445  6
                     // com\\googlecode\\sparkleg\\Sparql.g:581:7: COALESCE expressionList
 21446  
                     {
 21447  6
                     COALESCE555=(Token)match(input,COALESCE,FOLLOW_COALESCE_in_builtInCall5921);  
 21448  6
                     stream_COALESCE.add(COALESCE555);
 21449  
 
 21450  6
 
 21451  12
                     pushFollow(FOLLOW_expressionList_in_builtInCall5923);
 21452  6
                     expressionList556=expressionList();
 21453  
 
 21454  6
                     state._fsp--;
 21455  6
 
 21456  6
                     stream_expressionList.add(expressionList556.getTree());
 21457  6
 
 21458  
                     // AST REWRITE
 21459  
                     // elements: expressionList, COALESCE
 21460  
                     // token labels: 
 21461  
                     // rule labels: retval
 21462  
                     // token list labels: 
 21463  6
                     // rule list labels: 
 21464  
                     // wildcard labels: 
 21465  6
                     retval.tree = root_0;
 21466  12
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21467  
 
 21468  6
                     root_0 = (Object)adaptor.nil();
 21469  
                     // 581:31: -> ^( COALESCE expressionList )
 21470  3
                     {
 21471  3
                         // com\\googlecode\\sparkleg\\Sparql.g:581:34: ^( COALESCE expressionList )
 21472  
                         {
 21473  6
                         Object root_1 = (Object)adaptor.nil();
 21474  9
                         root_1 = (Object)adaptor.becomeRoot(
 21475  3
                         stream_COALESCE.nextNode()
 21476  
                         , root_1);
 21477  
 
 21478  9
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 21479  3
 
 21480  6
                         adaptor.addChild(root_0, root_1);
 21481  3
                         }
 21482  
 
 21483  3
                     }
 21484  
 
 21485  3
 
 21486  9
                     retval.tree = root_0;
 21487  
 
 21488  
                     }
 21489  9
                     break;
 21490  3
                 case 43 :
 21491  
                     // com\\googlecode\\sparkleg\\Sparql.g:582:7: IF OPEN_BRACE e1= expression COMMA e2= expression COMMA e3= expression CLOSE_BRACE
 21492  3
                     {
 21493  3
                     IF557=(Token)match(input,IF,FOLLOW_IF_in_builtInCall5939);  
 21494  6
                     stream_IF.add(IF557);
 21495  
 
 21496  3
 
 21497  6
                     OPEN_BRACE558=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5941);  
 21498  3
                     stream_OPEN_BRACE.add(OPEN_BRACE558);
 21499  
 
 21500  3
 
 21501  6
                     pushFollow(FOLLOW_expression_in_builtInCall5945);
 21502  3
                     e1=expression();
 21503  3
 
 21504  3
                     state._fsp--;
 21505  3
 
 21506  3
                     stream_expression.add(e1.getTree());
 21507  3
 
 21508  6
                     COMMA559=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5947);  
 21509  3
                     stream_COMMA.add(COMMA559);
 21510  
 
 21511  
 
 21512  3
                     pushFollow(FOLLOW_expression_in_builtInCall5951);
 21513  3
                     e2=expression();
 21514  
 
 21515  3
                     state._fsp--;
 21516  
 
 21517  3
                     stream_expression.add(e2.getTree());
 21518  3
 
 21519  6
                     COMMA560=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5953);  
 21520  6
                     stream_COMMA.add(COMMA560);
 21521  3
 
 21522  3
 
 21523  3
                     pushFollow(FOLLOW_expression_in_builtInCall5957);
 21524  6
                     e3=expression();
 21525  
 
 21526  3
                     state._fsp--;
 21527  
 
 21528  3
                     stream_expression.add(e3.getTree());
 21529  3
 
 21530  6
                     CLOSE_BRACE561=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5959);  
 21531  3
                     stream_CLOSE_BRACE.add(CLOSE_BRACE561);
 21532  
 
 21533  
 
 21534  3
                     // AST REWRITE
 21535  
                     // elements: e2, e1, IF, e3
 21536  3
                     // token labels: 
 21537  
                     // rule labels: e3, retval, e1, e2
 21538  3
                     // token list labels: 
 21539  
                     // rule list labels: 
 21540  3
                     // wildcard labels: 
 21541  3
                     retval.tree = root_0;
 21542  3
                     RewriteRuleSubtreeStream stream_e3=new RewriteRuleSubtreeStream(adaptor,"rule e3",e3!=null?e3.tree:null);
 21543  3
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21544  3
                     RewriteRuleSubtreeStream stream_e1=new RewriteRuleSubtreeStream(adaptor,"rule e1",e1!=null?e1.tree:null);
 21545  3
                     RewriteRuleSubtreeStream stream_e2=new RewriteRuleSubtreeStream(adaptor,"rule e2",e2!=null?e2.tree:null);
 21546  3
 
 21547  3
                     root_0 = (Object)adaptor.nil();
 21548  
                     // 582:87: -> ^( IF $e1 $e2 $e3)
 21549  3
                     {
 21550  
                         // com\\googlecode\\sparkleg\\Sparql.g:582:90: ^( IF $e1 $e2 $e3)
 21551  
                         {
 21552  3
                         Object root_1 = (Object)adaptor.nil();
 21553  6
                         root_1 = (Object)adaptor.becomeRoot(
 21554  3
                         stream_IF.nextNode()
 21555  
                         , root_1);
 21556  
 
 21557  6
                         adaptor.addChild(root_1, stream_e1.nextTree());
 21558  3
 
 21559  3
                         adaptor.addChild(root_1, stream_e2.nextTree());
 21560  
 
 21561  6
                         adaptor.addChild(root_1, stream_e3.nextTree());
 21562  3
 
 21563  3
                         adaptor.addChild(root_0, root_1);
 21564  3
                         }
 21565  
 
 21566  3
                     }
 21567  
 
 21568  3
 
 21569  6
                     retval.tree = root_0;
 21570  
 
 21571  
                     }
 21572  6
                     break;
 21573  3
                 case 44 :
 21574  
                     // com\\googlecode\\sparkleg\\Sparql.g:583:7: STRLANG OPEN_BRACE expression COMMA expression CLOSE_BRACE
 21575  3
                     {
 21576  3
                     STRLANG562=(Token)match(input,STRLANG,FOLLOW_STRLANG_in_builtInCall5982);  
 21577  6
                     stream_STRLANG.add(STRLANG562);
 21578  
 
 21579  3
 
 21580  6
                     OPEN_BRACE563=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5984);  
 21581  3
                     stream_OPEN_BRACE.add(OPEN_BRACE563);
 21582  
 
 21583  
 
 21584  3
                     pushFollow(FOLLOW_expression_in_builtInCall5986);
 21585  3
                     expression564=expression();
 21586  
 
 21587  3
                     state._fsp--;
 21588  
 
 21589  3
                     stream_expression.add(expression564.getTree());
 21590  3
 
 21591  6
                     COMMA565=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5988);  
 21592  3
                     stream_COMMA.add(COMMA565);
 21593  3
 
 21594  
 
 21595  3
                     pushFollow(FOLLOW_expression_in_builtInCall5990);
 21596  3
                     expression566=expression();
 21597  
 
 21598  6
                     state._fsp--;
 21599  3
 
 21600  3
                     stream_expression.add(expression566.getTree());
 21601  
 
 21602  3
                     CLOSE_BRACE567=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5992);  
 21603  6
                     stream_CLOSE_BRACE.add(CLOSE_BRACE567);
 21604  
 
 21605  3
 
 21606  
                     // AST REWRITE
 21607  3
                     // elements: expression, expression, STRLANG
 21608  
                     // token labels: 
 21609  
                     // rule labels: retval
 21610  
                     // token list labels: 
 21611  
                     // rule list labels: 
 21612  
                     // wildcard labels: 
 21613  6
                     retval.tree = root_0;
 21614  3
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21615  
 
 21616  6
                     root_0 = (Object)adaptor.nil();
 21617  
                     // 583:66: -> ^( STRLANG expression expression )
 21618  
                     {
 21619  
                         // com\\googlecode\\sparkleg\\Sparql.g:583:69: ^( STRLANG expression expression )
 21620  3
                         {
 21621  6
                         Object root_1 = (Object)adaptor.nil();
 21622  3
                         root_1 = (Object)adaptor.becomeRoot(
 21623  
                         stream_STRLANG.nextNode()
 21624  3
                         , root_1);
 21625  3
 
 21626  3
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21627  
 
 21628  6
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21629  3
 
 21630  3
                         adaptor.addChild(root_0, root_1);
 21631  3
                         }
 21632  
 
 21633  3
                     }
 21634  
 
 21635  3
 
 21636  6
                     retval.tree = root_0;
 21637  
 
 21638  
                     }
 21639  6
                     break;
 21640  3
                 case 45 :
 21641  
                     // com\\googlecode\\sparkleg\\Sparql.g:584:7: STRDT OPEN_BRACE expression COMMA expression CLOSE_BRACE
 21642  3
                     {
 21643  3
                     STRDT568=(Token)match(input,STRDT,FOLLOW_STRDT_in_builtInCall6010);  
 21644  6
                     stream_STRDT.add(STRDT568);
 21645  
 
 21646  3
 
 21647  6
                     OPEN_BRACE569=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6012);  
 21648  3
                     stream_OPEN_BRACE.add(OPEN_BRACE569);
 21649  
 
 21650  
 
 21651  3
                     pushFollow(FOLLOW_expression_in_builtInCall6014);
 21652  3
                     expression570=expression();
 21653  
 
 21654  3
                     state._fsp--;
 21655  
 
 21656  3
                     stream_expression.add(expression570.getTree());
 21657  3
 
 21658  6
                     COMMA571=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall6016);  
 21659  3
                     stream_COMMA.add(COMMA571);
 21660  3
 
 21661  
 
 21662  3
                     pushFollow(FOLLOW_expression_in_builtInCall6018);
 21663  3
                     expression572=expression();
 21664  
 
 21665  6
                     state._fsp--;
 21666  3
 
 21667  3
                     stream_expression.add(expression572.getTree());
 21668  
 
 21669  3
                     CLOSE_BRACE573=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6020);  
 21670  6
                     stream_CLOSE_BRACE.add(CLOSE_BRACE573);
 21671  
 
 21672  3
 
 21673  
                     // AST REWRITE
 21674  3
                     // elements: STRDT, expression, expression
 21675  
                     // token labels: 
 21676  
                     // rule labels: retval
 21677  
                     // token list labels: 
 21678  
                     // rule list labels: 
 21679  
                     // wildcard labels: 
 21680  6
                     retval.tree = root_0;
 21681  3
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21682  
 
 21683  6
                     root_0 = (Object)adaptor.nil();
 21684  
                     // 584:64: -> ^( STRDT expression expression )
 21685  
                     {
 21686  
                         // com\\googlecode\\sparkleg\\Sparql.g:584:67: ^( STRDT expression expression )
 21687  15
                         {
 21688  18
                         Object root_1 = (Object)adaptor.nil();
 21689  3
                         root_1 = (Object)adaptor.becomeRoot(
 21690  
                         stream_STRDT.nextNode()
 21691  15
                         , root_1);
 21692  15
 
 21693  3
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21694  
 
 21695  18
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21696  15
 
 21697  3
                         adaptor.addChild(root_0, root_1);
 21698  15
                         }
 21699  
 
 21700  15
                     }
 21701  
 
 21702  15
 
 21703  18
                     retval.tree = root_0;
 21704  
 
 21705  
                     }
 21706  18
                     break;
 21707  15
                 case 46 :
 21708  
                     // com\\googlecode\\sparkleg\\Sparql.g:585:7: SAMETERM OPEN_BRACE expression COMMA expression CLOSE_BRACE
 21709  15
                     {
 21710  15
                     SAMETERM574=(Token)match(input,SAMETERM,FOLLOW_SAMETERM_in_builtInCall6038);  
 21711  30
                     stream_SAMETERM.add(SAMETERM574);
 21712  
 
 21713  15
 
 21714  30
                     OPEN_BRACE575=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6040);  
 21715  15
                     stream_OPEN_BRACE.add(OPEN_BRACE575);
 21716  
 
 21717  
 
 21718  15
                     pushFollow(FOLLOW_expression_in_builtInCall6042);
 21719  15
                     expression576=expression();
 21720  
 
 21721  15
                     state._fsp--;
 21722  
 
 21723  15
                     stream_expression.add(expression576.getTree());
 21724  15
 
 21725  30
                     COMMA577=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall6044);  
 21726  15
                     stream_COMMA.add(COMMA577);
 21727  15
 
 21728  
 
 21729  15
                     pushFollow(FOLLOW_expression_in_builtInCall6046);
 21730  15
                     expression578=expression();
 21731  
 
 21732  30
                     state._fsp--;
 21733  15
 
 21734  15
                     stream_expression.add(expression578.getTree());
 21735  
 
 21736  15
                     CLOSE_BRACE579=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6048);  
 21737  30
                     stream_CLOSE_BRACE.add(CLOSE_BRACE579);
 21738  
 
 21739  15
 
 21740  
                     // AST REWRITE
 21741  15
                     // elements: expression, expression, SAMETERM
 21742  
                     // token labels: 
 21743  
                     // rule labels: retval
 21744  
                     // token list labels: 
 21745  
                     // rule list labels: 
 21746  
                     // wildcard labels: 
 21747  30
                     retval.tree = root_0;
 21748  15
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21749  
 
 21750  30
                     root_0 = (Object)adaptor.nil();
 21751  
                     // 585:67: -> ^( SAMETERM expression expression )
 21752  
                     {
 21753  
                         // com\\googlecode\\sparkleg\\Sparql.g:585:70: ^( SAMETERM expression expression )
 21754  4
                         {
 21755  19
                         Object root_1 = (Object)adaptor.nil();
 21756  15
                         root_1 = (Object)adaptor.becomeRoot(
 21757  
                         stream_SAMETERM.nextNode()
 21758  4
                         , root_1);
 21759  4
 
 21760  15
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21761  
 
 21762  19
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21763  4
 
 21764  15
                         adaptor.addChild(root_0, root_1);
 21765  4
                         }
 21766  
 
 21767  4
                     }
 21768  
 
 21769  4
 
 21770  19
                     retval.tree = root_0;
 21771  
 
 21772  
                     }
 21773  15
                     break;
 21774  
                 case 47 :
 21775  
                     // com\\googlecode\\sparkleg\\Sparql.g:586:7: ISIRI OPEN_BRACE expression CLOSE_BRACE
 21776  
                     {
 21777  4
                     ISIRI580=(Token)match(input,ISIRI,FOLLOW_ISIRI_in_builtInCall6066);  
 21778  4
                     stream_ISIRI.add(ISIRI580);
 21779  
 
 21780  4
 
 21781  8
                     OPEN_BRACE581=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6068);  
 21782  4
                     stream_OPEN_BRACE.add(OPEN_BRACE581);
 21783  4
 
 21784  
 
 21785  4
                     pushFollow(FOLLOW_expression_in_builtInCall6070);
 21786  4
                     expression582=expression();
 21787  
 
 21788  8
                     state._fsp--;
 21789  4
 
 21790  4
                     stream_expression.add(expression582.getTree());
 21791  
 
 21792  4
                     CLOSE_BRACE583=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6072);  
 21793  8
                     stream_CLOSE_BRACE.add(CLOSE_BRACE583);
 21794  
 
 21795  4
 
 21796  
                     // AST REWRITE
 21797  
                     // elements: expression, ISIRI
 21798  
                     // token labels: 
 21799  
                     // rule labels: retval
 21800  
                     // token list labels: 
 21801  4
                     // rule list labels: 
 21802  
                     // wildcard labels: 
 21803  4
                     retval.tree = root_0;
 21804  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21805  
 
 21806  4
                     root_0 = (Object)adaptor.nil();
 21807  
                     // 586:47: -> ^( ISIRI expression )
 21808  1
                     {
 21809  1
                         // com\\googlecode\\sparkleg\\Sparql.g:586:50: ^( ISIRI expression )
 21810  
                         {
 21811  4
                         Object root_1 = (Object)adaptor.nil();
 21812  5
                         root_1 = (Object)adaptor.becomeRoot(
 21813  1
                         stream_ISIRI.nextNode()
 21814  
                         , root_1);
 21815  
 
 21816  5
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21817  1
 
 21818  4
                         adaptor.addChild(root_0, root_1);
 21819  1
                         }
 21820  
 
 21821  1
                     }
 21822  
 
 21823  1
 
 21824  5
                     retval.tree = root_0;
 21825  
 
 21826  
                     }
 21827  4
                     break;
 21828  
                 case 48 :
 21829  
                     // com\\googlecode\\sparkleg\\Sparql.g:587:7: ISURI OPEN_BRACE expression CLOSE_BRACE
 21830  
                     {
 21831  1
                     ISURI584=(Token)match(input,ISURI,FOLLOW_ISURI_in_builtInCall6088);  
 21832  1
                     stream_ISURI.add(ISURI584);
 21833  
 
 21834  1
 
 21835  2
                     OPEN_BRACE585=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6090);  
 21836  1
                     stream_OPEN_BRACE.add(OPEN_BRACE585);
 21837  1
 
 21838  
 
 21839  1
                     pushFollow(FOLLOW_expression_in_builtInCall6092);
 21840  1
                     expression586=expression();
 21841  
 
 21842  2
                     state._fsp--;
 21843  1
 
 21844  1
                     stream_expression.add(expression586.getTree());
 21845  
 
 21846  1
                     CLOSE_BRACE587=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6094);  
 21847  2
                     stream_CLOSE_BRACE.add(CLOSE_BRACE587);
 21848  
 
 21849  1
 
 21850  
                     // AST REWRITE
 21851  
                     // elements: expression, ISURI
 21852  
                     // token labels: 
 21853  
                     // rule labels: retval
 21854  
                     // token list labels: 
 21855  1
                     // rule list labels: 
 21856  
                     // wildcard labels: 
 21857  1
                     retval.tree = root_0;
 21858  2
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21859  
 
 21860  1
                     root_0 = (Object)adaptor.nil();
 21861  
                     // 587:47: -> ^( ISURI expression )
 21862  4
                     {
 21863  4
                         // com\\googlecode\\sparkleg\\Sparql.g:587:50: ^( ISURI expression )
 21864  
                         {
 21865  1
                         Object root_1 = (Object)adaptor.nil();
 21866  5
                         root_1 = (Object)adaptor.becomeRoot(
 21867  4
                         stream_ISURI.nextNode()
 21868  
                         , root_1);
 21869  
 
 21870  5
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21871  4
 
 21872  1
                         adaptor.addChild(root_0, root_1);
 21873  4
                         }
 21874  
 
 21875  4
                     }
 21876  
 
 21877  4
 
 21878  5
                     retval.tree = root_0;
 21879  
 
 21880  
                     }
 21881  1
                     break;
 21882  
                 case 49 :
 21883  
                     // com\\googlecode\\sparkleg\\Sparql.g:588:7: ISBLANK OPEN_BRACE expression CLOSE_BRACE
 21884  
                     {
 21885  4
                     ISBLANK588=(Token)match(input,ISBLANK,FOLLOW_ISBLANK_in_builtInCall6110);  
 21886  4
                     stream_ISBLANK.add(ISBLANK588);
 21887  
 
 21888  4
 
 21889  8
                     OPEN_BRACE589=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6112);  
 21890  4
                     stream_OPEN_BRACE.add(OPEN_BRACE589);
 21891  4
 
 21892  
 
 21893  4
                     pushFollow(FOLLOW_expression_in_builtInCall6114);
 21894  4
                     expression590=expression();
 21895  
 
 21896  8
                     state._fsp--;
 21897  4
 
 21898  4
                     stream_expression.add(expression590.getTree());
 21899  
 
 21900  4
                     CLOSE_BRACE591=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6116);  
 21901  8
                     stream_CLOSE_BRACE.add(CLOSE_BRACE591);
 21902  
 
 21903  4
 
 21904  
                     // AST REWRITE
 21905  
                     // elements: expression, ISBLANK
 21906  
                     // token labels: 
 21907  
                     // rule labels: retval
 21908  
                     // token list labels: 
 21909  4
                     // rule list labels: 
 21910  
                     // wildcard labels: 
 21911  4
                     retval.tree = root_0;
 21912  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21913  
 
 21914  4
                     root_0 = (Object)adaptor.nil();
 21915  
                     // 588:49: -> ^( ISBLANK expression )
 21916  4
                     {
 21917  4
                         // com\\googlecode\\sparkleg\\Sparql.g:588:52: ^( ISBLANK expression )
 21918  
                         {
 21919  4
                         Object root_1 = (Object)adaptor.nil();
 21920  8
                         root_1 = (Object)adaptor.becomeRoot(
 21921  4
                         stream_ISBLANK.nextNode()
 21922  
                         , root_1);
 21923  
 
 21924  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21925  4
 
 21926  4
                         adaptor.addChild(root_0, root_1);
 21927  4
                         }
 21928  
 
 21929  4
                     }
 21930  
 
 21931  4
 
 21932  8
                     retval.tree = root_0;
 21933  
 
 21934  
                     }
 21935  4
                     break;
 21936  
                 case 50 :
 21937  
                     // com\\googlecode\\sparkleg\\Sparql.g:589:7: ISLITERAL OPEN_BRACE expression CLOSE_BRACE
 21938  
                     {
 21939  4
                     ISLITERAL592=(Token)match(input,ISLITERAL,FOLLOW_ISLITERAL_in_builtInCall6133);  
 21940  4
                     stream_ISLITERAL.add(ISLITERAL592);
 21941  
 
 21942  4
 
 21943  8
                     OPEN_BRACE593=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6135);  
 21944  4
                     stream_OPEN_BRACE.add(OPEN_BRACE593);
 21945  4
 
 21946  
 
 21947  4
                     pushFollow(FOLLOW_expression_in_builtInCall6137);
 21948  4
                     expression594=expression();
 21949  
 
 21950  8
                     state._fsp--;
 21951  4
 
 21952  4
                     stream_expression.add(expression594.getTree());
 21953  
 
 21954  4
                     CLOSE_BRACE595=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6139);  
 21955  8
                     stream_CLOSE_BRACE.add(CLOSE_BRACE595);
 21956  
 
 21957  4
 
 21958  
                     // AST REWRITE
 21959  
                     // elements: expression, ISLITERAL
 21960  
                     // token labels: 
 21961  
                     // rule labels: retval
 21962  
                     // token list labels: 
 21963  4
                     // rule list labels: 
 21964  
                     // wildcard labels: 
 21965  4
                     retval.tree = root_0;
 21966  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21967  
 
 21968  4
                     root_0 = (Object)adaptor.nil();
 21969  
                     // 589:51: -> ^( ISLITERAL expression )
 21970  2
                     {
 21971  2
                         // com\\googlecode\\sparkleg\\Sparql.g:589:54: ^( ISLITERAL expression )
 21972  
                         {
 21973  4
                         Object root_1 = (Object)adaptor.nil();
 21974  6
                         root_1 = (Object)adaptor.becomeRoot(
 21975  2
                         stream_ISLITERAL.nextNode()
 21976  
                         , root_1);
 21977  
 
 21978  6
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21979  2
 
 21980  4
                         adaptor.addChild(root_0, root_1);
 21981  2
                         }
 21982  
 
 21983  2
                     }
 21984  
 
 21985  2
 
 21986  6
                     retval.tree = root_0;
 21987  
 
 21988  
                     }
 21989  4
                     break;
 21990  
                 case 51 :
 21991  
                     // com\\googlecode\\sparkleg\\Sparql.g:590:7: ISNUMERIC OPEN_BRACE expression CLOSE_BRACE
 21992  
                     {
 21993  2
                     ISNUMERIC596=(Token)match(input,ISNUMERIC,FOLLOW_ISNUMERIC_in_builtInCall6155);  
 21994  2
                     stream_ISNUMERIC.add(ISNUMERIC596);
 21995  
 
 21996  2
 
 21997  4
                     OPEN_BRACE597=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6157);  
 21998  2
                     stream_OPEN_BRACE.add(OPEN_BRACE597);
 21999  2
 
 22000  
 
 22001  2
                     pushFollow(FOLLOW_expression_in_builtInCall6159);
 22002  2
                     expression598=expression();
 22003  
 
 22004  4
                     state._fsp--;
 22005  2
 
 22006  2
                     stream_expression.add(expression598.getTree());
 22007  
 
 22008  2
                     CLOSE_BRACE599=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6161);  
 22009  4
                     stream_CLOSE_BRACE.add(CLOSE_BRACE599);
 22010  
 
 22011  2
 
 22012  
                     // AST REWRITE
 22013  
                     // elements: expression, ISNUMERIC
 22014  
                     // token labels: 
 22015  
                     // rule labels: retval
 22016  
                     // token list labels: 
 22017  2
                     // rule list labels: 
 22018  
                     // wildcard labels: 
 22019  2
                     retval.tree = root_0;
 22020  4
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22021  
 
 22022  2
                     root_0 = (Object)adaptor.nil();
 22023  
                     // 590:51: -> ^( ISNUMERIC expression )
 22024  21
                     {
 22025  21
                         // com\\googlecode\\sparkleg\\Sparql.g:590:54: ^( ISNUMERIC expression )
 22026  
                         {
 22027  23
                         Object root_1 = (Object)adaptor.nil();
 22028  2
                         root_1 = (Object)adaptor.becomeRoot(
 22029  21
                         stream_ISNUMERIC.nextNode()
 22030  
                         , root_1);
 22031  
 
 22032  2
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22033  
 
 22034  2
                         adaptor.addChild(root_0, root_1);
 22035  
                         }
 22036  
 
 22037  
                     }
 22038  21
 
 22039  21
 
 22040  2
                     retval.tree = root_0;
 22041  21
 
 22042  
                     }
 22043  2
                     break;
 22044  21
                 case 52 :
 22045  
                     // com\\googlecode\\sparkleg\\Sparql.g:591:7: regexExpression
 22046  
                     {
 22047  21
                     pushFollow(FOLLOW_regexExpression_in_builtInCall6177);
 22048  21
                     regexExpression600=regexExpression();
 22049  21
 
 22050  21
                     state._fsp--;
 22051  
 
 22052  42
                     stream_regexExpression.add(regexExpression600.getTree());
 22053  
 
 22054  
                     // AST REWRITE
 22055  
                     // elements: regexExpression
 22056  10
                     // token labels: 
 22057  10
                     // rule labels: retval
 22058  
                     // token list labels: 
 22059  10
                     // rule list labels: 
 22060  
                     // wildcard labels: 
 22061  31
                     retval.tree = root_0;
 22062  21
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22063  
 
 22064  21
                     root_0 = (Object)adaptor.nil();
 22065  
                     // 591:23: -> regexExpression
 22066  
                     {
 22067  21
                         adaptor.addChild(root_0, stream_regexExpression.nextTree());
 22068  
 
 22069  
                     }
 22070  10
 
 22071  10
 
 22072  21
                     retval.tree = root_0;
 22073  10
 
 22074  
                     }
 22075  21
                     break;
 22076  10
                 case 53 :
 22077  
                     // com\\googlecode\\sparkleg\\Sparql.g:592:7: existsFunction
 22078  
                     {
 22079  10
                     pushFollow(FOLLOW_existsFunction_in_builtInCall6189);
 22080  10
                     existsFunction601=existsFunction();
 22081  10
 
 22082  10
                     state._fsp--;
 22083  
 
 22084  20
                     stream_existsFunction.add(existsFunction601.getTree());
 22085  
 
 22086  
                     // AST REWRITE
 22087  
                     // elements: existsFunction
 22088  23
                     // token labels: 
 22089  23
                     // rule labels: retval
 22090  
                     // token list labels: 
 22091  23
                     // rule list labels: 
 22092  
                     // wildcard labels: 
 22093  33
                     retval.tree = root_0;
 22094  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22095  
 
 22096  10
                     root_0 = (Object)adaptor.nil();
 22097  
                     // 592:22: -> existsFunction
 22098  
                     {
 22099  10
                         adaptor.addChild(root_0, stream_existsFunction.nextTree());
 22100  
 
 22101  
                     }
 22102  23
 
 22103  23
 
 22104  10
                     retval.tree = root_0;
 22105  23
 
 22106  
                     }
 22107  10
                     break;
 22108  23
                 case 54 :
 22109  
                     // com\\googlecode\\sparkleg\\Sparql.g:593:7: notExistsFunction
 22110  
                     {
 22111  23
                     pushFollow(FOLLOW_notExistsFunction_in_builtInCall6201);
 22112  23
                     notExistsFunction602=notExistsFunction();
 22113  23
 
 22114  23
                     state._fsp--;
 22115  
 
 22116  23
                     stream_notExistsFunction.add(notExistsFunction602.getTree());
 22117  
 
 22118  
                     // AST REWRITE
 22119  266
                     // elements: notExistsFunction
 22120  
                     // token labels: 
 22121  
                     // rule labels: retval
 22122  266
                     // token list labels: 
 22123  266
                     // rule list labels: 
 22124  
                     // wildcard labels: 
 22125  23
                     retval.tree = root_0;
 22126  23
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22127  
 
 22128  23
                     root_0 = (Object)adaptor.nil();
 22129  
                     // 593:25: -> notExistsFunction
 22130  
                     {
 22131  23
                         adaptor.addChild(root_0, stream_notExistsFunction.nextTree());
 22132  
 
 22133  
                     }
 22134  
 
 22135  266
 
 22136  289
                     retval.tree = root_0;
 22137  
 
 22138  
                     }
 22139  
                     break;
 22140  
 
 22141  21
             }
 22142  266
             retval.stop = input.LT(-1);
 22143  21
 
 22144  
 
 22145  266
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22146  266
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22147  
 
 22148  
         }
 22149  0
         catch (RecognitionException re) {
 22150  21
             reportError(re);
 22151  21
             recover(input,re);
 22152  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22153  
 
 22154  21
         }
 22155  
 
 22156  21
         finally {
 22157  21
                 // do for sure before leaving
 22158  287
         }
 22159  287
         return retval;
 22160  21
     }
 22161  21
     // $ANTLR end "builtInCall"
 22162  
 
 22163  21
 
 22164  21
     public static class regexExpression_return extends ParserRuleReturnScope {
 22165  21
         Object tree;
 22166  21
         public Object getTree() { return tree; }
 22167  
     };
 22168  21
 
 22169  21
 
 22170  21
     // $ANTLR start "regexExpression"
 22171  21
     // com\\googlecode\\sparkleg\\Sparql.g:596:1: regexExpression : REGEX OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( REGEX ( expression )* ) ;
 22172  21
     public final SparqlParser.regexExpression_return regexExpression() throws RecognitionException {
 22173  42
         SparqlParser.regexExpression_return retval = new SparqlParser.regexExpression_return();
 22174  42
         retval.start = input.LT(1);
 22175  21
 
 22176  21
 
 22177  42
         Object root_0 = null;
 22178  
 
 22179  21
         Token REGEX603=null;
 22180  21
         Token OPEN_BRACE604=null;
 22181  21
         Token COMMA606=null;
 22182  42
         Token COMMA608=null;
 22183  42
         Token CLOSE_BRACE610=null;
 22184  21
         SparqlParser.expression_return expression605 =null;
 22185  
 
 22186  42
         SparqlParser.expression_return expression607 =null;
 22187  21
 
 22188  21
         SparqlParser.expression_return expression609 =null;
 22189  
 
 22190  21
 
 22191  42
         Object REGEX603_tree=null;
 22192  21
         Object OPEN_BRACE604_tree=null;
 22193  42
         Object COMMA606_tree=null;
 22194  21
         Object COMMA608_tree=null;
 22195  42
         Object CLOSE_BRACE610_tree=null;
 22196  21
         RewriteRuleTokenStream stream_REGEX=new RewriteRuleTokenStream(adaptor,"token REGEX");
 22197  42
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 22198  42
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 22199  21
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 22200  21
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22201  21
         try {
 22202  21
             // com\\googlecode\\sparkleg\\Sparql.g:597:5: ( REGEX OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( REGEX ( expression )* ) )
 22203  
             // com\\googlecode\\sparkleg\\Sparql.g:597:7: REGEX OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE
 22204  21
             {
 22205  21
             REGEX603=(Token)match(input,REGEX,FOLLOW_REGEX_in_regexExpression6222);  
 22206  42
             stream_REGEX.add(REGEX603);
 22207  
 
 22208  
 
 22209  42
             OPEN_BRACE604=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_regexExpression6224);  
 22210  42
             stream_OPEN_BRACE.add(OPEN_BRACE604);
 22211  
 
 22212  
 
 22213  27
             pushFollow(FOLLOW_expression_in_regexExpression6226);
 22214  21
             expression605=expression();
 22215  
 
 22216  21
             state._fsp--;
 22217  
 
 22218  42
             stream_expression.add(expression605.getTree());
 22219  
 
 22220  21
             COMMA606=(Token)match(input,COMMA,FOLLOW_COMMA_in_regexExpression6228);  
 22221  21
             stream_COMMA.add(COMMA606);
 22222  6
 
 22223  6
 
 22224  21
             pushFollow(FOLLOW_expression_in_regexExpression6230);
 22225  21
             expression607=expression();
 22226  6
 
 22227  27
             state._fsp--;
 22228  
 
 22229  27
             stream_expression.add(expression607.getTree());
 22230  
 
 22231  6
             // com\\googlecode\\sparkleg\\Sparql.g:597:52: ( COMMA expression )?
 22232  21
             int alt127=2;
 22233  21
             switch ( input.LA(1) ) {
 22234  
                 case COMMA:
 22235  
                     {
 22236  6
                     alt127=1;
 22237  
                     }
 22238  
                     break;
 22239  21
             }
 22240  21
 
 22241  21
             switch (alt127) {
 22242  
                 case 1 :
 22243  
                     // com\\googlecode\\sparkleg\\Sparql.g:597:53: COMMA expression
 22244  
                     {
 22245  6
                     COMMA608=(Token)match(input,COMMA,FOLLOW_COMMA_in_regexExpression6233);  
 22246  6
                     stream_COMMA.add(COMMA608);
 22247  
 
 22248  
 
 22249  6
                     pushFollow(FOLLOW_expression_in_regexExpression6235);
 22250  27
                     expression609=expression();
 22251  21
 
 22252  6
                     state._fsp--;
 22253  21
 
 22254  6
                     stream_expression.add(expression609.getTree());
 22255  
 
 22256  
                     }
 22257  
                     break;
 22258  21
 
 22259  21
             }
 22260  
 
 22261  
 
 22262  21
             CLOSE_BRACE610=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_regexExpression6239);  
 22263  21
             stream_CLOSE_BRACE.add(CLOSE_BRACE610);
 22264  69
 
 22265  48
 
 22266  
             // AST REWRITE
 22267  
             // elements: REGEX, expression
 22268  21
             // token labels: 
 22269  
             // rule labels: retval
 22270  21
             // token list labels: 
 22271  
             // rule list labels: 
 22272  
             // wildcard labels: 
 22273  21
             retval.tree = root_0;
 22274  21
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22275  
 
 22276  42
             root_0 = (Object)adaptor.nil();
 22277  
             // 597:84: -> ^( REGEX ( expression )* )
 22278  
             {
 22279  
                 // com\\googlecode\\sparkleg\\Sparql.g:597:87: ^( REGEX ( expression )* )
 22280  21
                 {
 22281  21
                 Object root_1 = (Object)adaptor.nil();
 22282  21
                 root_1 = (Object)adaptor.becomeRoot(
 22283  21
                 stream_REGEX.nextNode()
 22284  21
                 , root_1);
 22285  
 
 22286  
                 // com\\googlecode\\sparkleg\\Sparql.g:597:95: ( expression )*
 22287  69
                 while ( stream_expression.hasNext() ) {
 22288  48
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22289  
 
 22290  
                 }
 22291  21
                 stream_expression.reset();
 22292  
 
 22293  21
                 adaptor.addChild(root_0, root_1);
 22294  
                 }
 22295  
 
 22296  21
             }
 22297  21
 
 22298  
 
 22299  21
             retval.tree = root_0;
 22300  
 
 22301  
             }
 22302  2
 
 22303  21
             retval.stop = input.LT(-1);
 22304  2
 
 22305  
 
 22306  21
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22307  21
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22308  
 
 22309  
         }
 22310  0
         catch (RecognitionException re) {
 22311  2
             reportError(re);
 22312  2
             recover(input,re);
 22313  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22314  
 
 22315  2
         }
 22316  
 
 22317  2
         finally {
 22318  2
                 // do for sure before leaving
 22319  23
         }
 22320  23
         return retval;
 22321  2
     }
 22322  2
     // $ANTLR end "regexExpression"
 22323  
 
 22324  2
 
 22325  2
     public static class subStringExpression_return extends ParserRuleReturnScope {
 22326  2
         Object tree;
 22327  2
         public Object getTree() { return tree; }
 22328  
     };
 22329  2
 
 22330  2
 
 22331  2
     // $ANTLR start "subStringExpression"
 22332  2
     // com\\googlecode\\sparkleg\\Sparql.g:600:1: subStringExpression : SUBSTR OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( SUBSTR ( expression )* ) ;
 22333  2
     public final SparqlParser.subStringExpression_return subStringExpression() throws RecognitionException {
 22334  4
         SparqlParser.subStringExpression_return retval = new SparqlParser.subStringExpression_return();
 22335  4
         retval.start = input.LT(1);
 22336  2
 
 22337  2
 
 22338  4
         Object root_0 = null;
 22339  
 
 22340  2
         Token SUBSTR611=null;
 22341  2
         Token OPEN_BRACE612=null;
 22342  2
         Token COMMA614=null;
 22343  4
         Token COMMA616=null;
 22344  4
         Token CLOSE_BRACE618=null;
 22345  2
         SparqlParser.expression_return expression613 =null;
 22346  
 
 22347  4
         SparqlParser.expression_return expression615 =null;
 22348  2
 
 22349  2
         SparqlParser.expression_return expression617 =null;
 22350  
 
 22351  2
 
 22352  4
         Object SUBSTR611_tree=null;
 22353  2
         Object OPEN_BRACE612_tree=null;
 22354  4
         Object COMMA614_tree=null;
 22355  2
         Object COMMA616_tree=null;
 22356  4
         Object CLOSE_BRACE618_tree=null;
 22357  2
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 22358  4
         RewriteRuleTokenStream stream_SUBSTR=new RewriteRuleTokenStream(adaptor,"token SUBSTR");
 22359  4
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 22360  2
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 22361  2
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22362  2
         try {
 22363  2
             // com\\googlecode\\sparkleg\\Sparql.g:601:5: ( SUBSTR OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( SUBSTR ( expression )* ) )
 22364  
             // com\\googlecode\\sparkleg\\Sparql.g:601:7: SUBSTR OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE
 22365  2
             {
 22366  2
             SUBSTR611=(Token)match(input,SUBSTR,FOLLOW_SUBSTR_in_subStringExpression6269);  
 22367  4
             stream_SUBSTR.add(SUBSTR611);
 22368  
 
 22369  
 
 22370  4
             OPEN_BRACE612=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_subStringExpression6271);  
 22371  4
             stream_OPEN_BRACE.add(OPEN_BRACE612);
 22372  
 
 22373  
 
 22374  3
             pushFollow(FOLLOW_expression_in_subStringExpression6273);
 22375  2
             expression613=expression();
 22376  
 
 22377  2
             state._fsp--;
 22378  
 
 22379  4
             stream_expression.add(expression613.getTree());
 22380  
 
 22381  2
             COMMA614=(Token)match(input,COMMA,FOLLOW_COMMA_in_subStringExpression6275);  
 22382  2
             stream_COMMA.add(COMMA614);
 22383  1
 
 22384  1
 
 22385  2
             pushFollow(FOLLOW_expression_in_subStringExpression6277);
 22386  2
             expression615=expression();
 22387  1
 
 22388  3
             state._fsp--;
 22389  
 
 22390  3
             stream_expression.add(expression615.getTree());
 22391  
 
 22392  1
             // com\\googlecode\\sparkleg\\Sparql.g:601:53: ( COMMA expression )?
 22393  2
             int alt128=2;
 22394  2
             switch ( input.LA(1) ) {
 22395  
                 case COMMA:
 22396  
                     {
 22397  1
                     alt128=1;
 22398  
                     }
 22399  
                     break;
 22400  2
             }
 22401  2
 
 22402  2
             switch (alt128) {
 22403  
                 case 1 :
 22404  
                     // com\\googlecode\\sparkleg\\Sparql.g:601:54: COMMA expression
 22405  
                     {
 22406  1
                     COMMA616=(Token)match(input,COMMA,FOLLOW_COMMA_in_subStringExpression6280);  
 22407  1
                     stream_COMMA.add(COMMA616);
 22408  
 
 22409  
 
 22410  1
                     pushFollow(FOLLOW_expression_in_subStringExpression6282);
 22411  3
                     expression617=expression();
 22412  2
 
 22413  1
                     state._fsp--;
 22414  2
 
 22415  1
                     stream_expression.add(expression617.getTree());
 22416  
 
 22417  
                     }
 22418  
                     break;
 22419  2
 
 22420  2
             }
 22421  
 
 22422  
 
 22423  2
             CLOSE_BRACE618=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_subStringExpression6286);  
 22424  2
             stream_CLOSE_BRACE.add(CLOSE_BRACE618);
 22425  7
 
 22426  5
 
 22427  
             // AST REWRITE
 22428  
             // elements: expression, SUBSTR
 22429  2
             // token labels: 
 22430  
             // rule labels: retval
 22431  2
             // token list labels: 
 22432  
             // rule list labels: 
 22433  
             // wildcard labels: 
 22434  2
             retval.tree = root_0;
 22435  2
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22436  
 
 22437  4
             root_0 = (Object)adaptor.nil();
 22438  
             // 601:85: -> ^( SUBSTR ( expression )* )
 22439  
             {
 22440  
                 // com\\googlecode\\sparkleg\\Sparql.g:601:88: ^( SUBSTR ( expression )* )
 22441  2
                 {
 22442  2
                 Object root_1 = (Object)adaptor.nil();
 22443  2
                 root_1 = (Object)adaptor.becomeRoot(
 22444  2
                 stream_SUBSTR.nextNode()
 22445  2
                 , root_1);
 22446  
 
 22447  
                 // com\\googlecode\\sparkleg\\Sparql.g:601:97: ( expression )*
 22448  7
                 while ( stream_expression.hasNext() ) {
 22449  5
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22450  
 
 22451  
                 }
 22452  2
                 stream_expression.reset();
 22453  
 
 22454  2
                 adaptor.addChild(root_0, root_1);
 22455  
                 }
 22456  
 
 22457  2
             }
 22458  2
 
 22459  
 
 22460  2
             retval.tree = root_0;
 22461  
 
 22462  
             }
 22463  10
 
 22464  2
             retval.stop = input.LT(-1);
 22465  10
 
 22466  
 
 22467  2
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22468  2
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22469  
 
 22470  
         }
 22471  0
         catch (RecognitionException re) {
 22472  10
             reportError(re);
 22473  10
             recover(input,re);
 22474  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22475  
 
 22476  10
         }
 22477  
 
 22478  10
         finally {
 22479  10
                 // do for sure before leaving
 22480  2
         }
 22481  2
         return retval;
 22482  10
     }
 22483  10
     // $ANTLR end "subStringExpression"
 22484  10
 
 22485  
 
 22486  10
     public static class existsFunction_return extends ParserRuleReturnScope {
 22487  
         Object tree;
 22488  10
         public Object getTree() { return tree; }
 22489  10
     };
 22490  10
 
 22491  
 
 22492  
     // $ANTLR start "existsFunction"
 22493  10
     // com\\googlecode\\sparkleg\\Sparql.g:604:1: existsFunction : EXISTS groupGraphPattern -> ^( EXISTS groupGraphPattern ) ;
 22494  10
     public final SparqlParser.existsFunction_return existsFunction() throws RecognitionException {
 22495  10
         SparqlParser.existsFunction_return retval = new SparqlParser.existsFunction_return();
 22496  20
         retval.start = input.LT(1);
 22497  
 
 22498  10
 
 22499  10
         Object root_0 = null;
 22500  
 
 22501  10
         Token EXISTS619=null;
 22502  10
         SparqlParser.groupGraphPattern_return groupGraphPattern620 =null;
 22503  
 
 22504  
 
 22505  10
         Object EXISTS619_tree=null;
 22506  10
         RewriteRuleTokenStream stream_EXISTS=new RewriteRuleTokenStream(adaptor,"token EXISTS");
 22507  20
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 22508  10
         try {
 22509  
             // com\\googlecode\\sparkleg\\Sparql.g:605:5: ( EXISTS groupGraphPattern -> ^( EXISTS groupGraphPattern ) )
 22510  10
             // com\\googlecode\\sparkleg\\Sparql.g:605:7: EXISTS groupGraphPattern
 22511  
             {
 22512  10
             EXISTS619=(Token)match(input,EXISTS,FOLLOW_EXISTS_in_existsFunction6316);  
 22513  10
             stream_EXISTS.add(EXISTS619);
 22514  
 
 22515  10
 
 22516  20
             pushFollow(FOLLOW_groupGraphPattern_in_existsFunction6318);
 22517  10
             groupGraphPattern620=groupGraphPattern();
 22518  
 
 22519  10
             state._fsp--;
 22520  10
 
 22521  10
             stream_groupGraphPattern.add(groupGraphPattern620.getTree());
 22522  10
 
 22523  
             // AST REWRITE
 22524  
             // elements: EXISTS, groupGraphPattern
 22525  
             // token labels: 
 22526  
             // rule labels: retval
 22527  
             // token list labels: 
 22528  10
             // rule list labels: 
 22529  
             // wildcard labels: 
 22530  10
             retval.tree = root_0;
 22531  10
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22532  10
 
 22533  10
             root_0 = (Object)adaptor.nil();
 22534  
             // 605:32: -> ^( EXISTS groupGraphPattern )
 22535  10
             {
 22536  10
                 // com\\googlecode\\sparkleg\\Sparql.g:605:35: ^( EXISTS groupGraphPattern )
 22537  
                 {
 22538  10
                 Object root_1 = (Object)adaptor.nil();
 22539  10
                 root_1 = (Object)adaptor.becomeRoot(
 22540  
                 stream_EXISTS.nextNode()
 22541  
                 , root_1);
 22542  
 
 22543  10
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 22544  
 
 22545  10
                 adaptor.addChild(root_0, root_1);
 22546  
                 }
 22547  
 
 22548  10
             }
 22549  10
 
 22550  
 
 22551  10
             retval.tree = root_0;
 22552  
 
 22553  
             }
 22554  23
 
 22555  10
             retval.stop = input.LT(-1);
 22556  23
 
 22557  
 
 22558  10
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22559  10
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22560  
 
 22561  
         }
 22562  0
         catch (RecognitionException re) {
 22563  23
             reportError(re);
 22564  23
             recover(input,re);
 22565  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22566  
 
 22567  23
         }
 22568  
 
 22569  23
         finally {
 22570  23
                 // do for sure before leaving
 22571  33
         }
 22572  10
         return retval;
 22573  
     }
 22574  23
     // $ANTLR end "existsFunction"
 22575  23
 
 22576  23
 
 22577  23
     public static class notExistsFunction_return extends ParserRuleReturnScope {
 22578  23
         Object tree;
 22579  23
         public Object getTree() { return tree; }
 22580  
     };
 22581  
 
 22582  
 
 22583  23
     // $ANTLR start "notExistsFunction"
 22584  23
     // com\\googlecode\\sparkleg\\Sparql.g:608:1: notExistsFunction : NOT EXISTS groupGraphPattern -> ^( NOT_EXISTS groupGraphPattern ) ;
 22585  
     public final SparqlParser.notExistsFunction_return notExistsFunction() throws RecognitionException {
 22586  23
         SparqlParser.notExistsFunction_return retval = new SparqlParser.notExistsFunction_return();
 22587  46
         retval.start = input.LT(1);
 22588  23
 
 22589  
 
 22590  23
         Object root_0 = null;
 22591  23
 
 22592  46
         Token NOT621=null;
 22593  23
         Token EXISTS622=null;
 22594  46
         SparqlParser.groupGraphPattern_return groupGraphPattern623 =null;
 22595  
 
 22596  23
 
 22597  23
         Object NOT621_tree=null;
 22598  23
         Object EXISTS622_tree=null;
 22599  23
         RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
 22600  23
         RewriteRuleTokenStream stream_EXISTS=new RewriteRuleTokenStream(adaptor,"token EXISTS");
 22601  23
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 22602  
         try {
 22603  
             // com\\googlecode\\sparkleg\\Sparql.g:609:5: ( NOT EXISTS groupGraphPattern -> ^( NOT_EXISTS groupGraphPattern ) )
 22604  
             // com\\googlecode\\sparkleg\\Sparql.g:609:7: NOT EXISTS groupGraphPattern
 22605  23
             {
 22606  46
             NOT621=(Token)match(input,NOT,FOLLOW_NOT_in_notExistsFunction6343);  
 22607  23
             stream_NOT.add(NOT621);
 22608  23
 
 22609  
 
 22610  23
             EXISTS622=(Token)match(input,EXISTS,FOLLOW_EXISTS_in_notExistsFunction6345);  
 22611  23
             stream_EXISTS.add(EXISTS622);
 22612  
 
 22613  23
 
 22614  46
             pushFollow(FOLLOW_groupGraphPattern_in_notExistsFunction6347);
 22615  23
             groupGraphPattern623=groupGraphPattern();
 22616  
 
 22617  23
             state._fsp--;
 22618  23
 
 22619  23
             stream_groupGraphPattern.add(groupGraphPattern623.getTree());
 22620  23
 
 22621  
             // AST REWRITE
 22622  
             // elements: groupGraphPattern
 22623  
             // token labels: 
 22624  
             // rule labels: retval
 22625  
             // token list labels: 
 22626  23
             // rule list labels: 
 22627  
             // wildcard labels: 
 22628  23
             retval.tree = root_0;
 22629  23
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22630  23
 
 22631  23
             root_0 = (Object)adaptor.nil();
 22632  
             // 609:36: -> ^( NOT_EXISTS groupGraphPattern )
 22633  23
             {
 22634  23
                 // com\\googlecode\\sparkleg\\Sparql.g:609:39: ^( NOT_EXISTS groupGraphPattern )
 22635  
                 {
 22636  23
                 Object root_1 = (Object)adaptor.nil();
 22637  23
                 root_1 = (Object)adaptor.becomeRoot(
 22638  
                 (Object)adaptor.create(NOT_EXISTS, "NOT_EXISTS")
 22639  
                 , root_1);
 22640  
 
 22641  23
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 22642  
 
 22643  23
                 adaptor.addChild(root_0, root_1);
 22644  
                 }
 22645  
 
 22646  23
             }
 22647  23
 
 22648  
 
 22649  23
             retval.tree = root_0;
 22650  
 
 22651  
             }
 22652  53
 
 22653  23
             retval.stop = input.LT(-1);
 22654  53
 
 22655  
 
 22656  23
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22657  23
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22658  
 
 22659  
         }
 22660  0
         catch (RecognitionException re) {
 22661  53
             reportError(re);
 22662  53
             recover(input,re);
 22663  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22664  
 
 22665  53
         }
 22666  
 
 22667  53
         finally {
 22668  53
                 // do for sure before leaving
 22669  76
         }
 22670  76
         return retval;
 22671  53
     }
 22672  53
     // $ANTLR end "notExistsFunction"
 22673  53
 
 22674  53
 
 22675  53
     public static class aggregate_return extends ParserRuleReturnScope {
 22676  53
         Object tree;
 22677  53
         public Object getTree() { return tree; }
 22678  53
     };
 22679  53
 
 22680  53
 
 22681  53
     // $ANTLR start "aggregate"
 22682  53
     // com\\googlecode\\sparkleg\\Sparql.g:612:1: aggregate : ( COUNT OPEN_BRACE ( DISTINCT )? ( ASTERISK | expression ) CLOSE_BRACE -> ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* ) | SUM OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SUM ( DISTINCT )* expression ) | MIN OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MIN ( DISTINCT )* expression ) | MAX OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MAX ( DISTINCT )* expression ) | AVG OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( AVG ( DISTINCT )* expression ) | SAMPLE OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SAMPLE ( DISTINCT )? expression ) | GROUP_CONCAT OPEN_BRACE ( DISTINCT )? expression ( SEMICOLON SEPARATOR EQUAL string )? CLOSE_BRACE -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* ) );
 22683  53
     public final SparqlParser.aggregate_return aggregate() throws RecognitionException {
 22684  106
         SparqlParser.aggregate_return retval = new SparqlParser.aggregate_return();
 22685  106
         retval.start = input.LT(1);
 22686  53
 
 22687  53
 
 22688  106
         Object root_0 = null;
 22689  53
 
 22690  106
         Token COUNT624=null;
 22691  106
         Token OPEN_BRACE625=null;
 22692  106
         Token DISTINCT626=null;
 22693  106
         Token ASTERISK627=null;
 22694  106
         Token CLOSE_BRACE629=null;
 22695  106
         Token SUM630=null;
 22696  106
         Token OPEN_BRACE631=null;
 22697  106
         Token DISTINCT632=null;
 22698  106
         Token CLOSE_BRACE634=null;
 22699  106
         Token MIN635=null;
 22700  53
         Token OPEN_BRACE636=null;
 22701  106
         Token DISTINCT637=null;
 22702  53
         Token CLOSE_BRACE639=null;
 22703  106
         Token MAX640=null;
 22704  53
         Token OPEN_BRACE641=null;
 22705  106
         Token DISTINCT642=null;
 22706  53
         Token CLOSE_BRACE644=null;
 22707  106
         Token AVG645=null;
 22708  53
         Token OPEN_BRACE646=null;
 22709  106
         Token DISTINCT647=null;
 22710  53
         Token CLOSE_BRACE649=null;
 22711  106
         Token SAMPLE650=null;
 22712  53
         Token OPEN_BRACE651=null;
 22713  106
         Token DISTINCT652=null;
 22714  53
         Token CLOSE_BRACE654=null;
 22715  53
         Token GROUP_CONCAT655=null;
 22716  106
         Token OPEN_BRACE656=null;
 22717  106
         Token DISTINCT657=null;
 22718  106
         Token SEMICOLON659=null;
 22719  106
         Token SEPARATOR660=null;
 22720  106
         Token EQUAL661=null;
 22721  106
         Token CLOSE_BRACE663=null;
 22722  106
         SparqlParser.expression_return expression628 =null;
 22723  53
 
 22724  106
         SparqlParser.expression_return expression633 =null;
 22725  53
 
 22726  106
         SparqlParser.expression_return expression638 =null;
 22727  53
 
 22728  106
         SparqlParser.expression_return expression643 =null;
 22729  53
 
 22730  106
         SparqlParser.expression_return expression648 =null;
 22731  53
 
 22732  106
         SparqlParser.expression_return expression653 =null;
 22733  53
 
 22734  106
         SparqlParser.expression_return expression658 =null;
 22735  53
 
 22736  106
         SparqlParser.string_return string662 =null;
 22737  53
 
 22738  53
 
 22739  106
         Object COUNT624_tree=null;
 22740  106
         Object OPEN_BRACE625_tree=null;
 22741  106
         Object DISTINCT626_tree=null;
 22742  106
         Object ASTERISK627_tree=null;
 22743  106
         Object CLOSE_BRACE629_tree=null;
 22744  106
         Object SUM630_tree=null;
 22745  106
         Object OPEN_BRACE631_tree=null;
 22746  106
         Object DISTINCT632_tree=null;
 22747  106
         Object CLOSE_BRACE634_tree=null;
 22748  106
         Object MIN635_tree=null;
 22749  106
         Object OPEN_BRACE636_tree=null;
 22750  106
         Object DISTINCT637_tree=null;
 22751  106
         Object CLOSE_BRACE639_tree=null;
 22752  106
         Object MAX640_tree=null;
 22753  106
         Object OPEN_BRACE641_tree=null;
 22754  106
         Object DISTINCT642_tree=null;
 22755  106
         Object CLOSE_BRACE644_tree=null;
 22756  106
         Object AVG645_tree=null;
 22757  106
         Object OPEN_BRACE646_tree=null;
 22758  106
         Object DISTINCT647_tree=null;
 22759  106
         Object CLOSE_BRACE649_tree=null;
 22760  106
         Object SAMPLE650_tree=null;
 22761  106
         Object OPEN_BRACE651_tree=null;
 22762  106
         Object DISTINCT652_tree=null;
 22763  106
         Object CLOSE_BRACE654_tree=null;
 22764  53
         Object GROUP_CONCAT655_tree=null;
 22765  53
         Object OPEN_BRACE656_tree=null;
 22766  106
         Object DISTINCT657_tree=null;
 22767  106
         Object SEMICOLON659_tree=null;
 22768  53
         Object SEPARATOR660_tree=null;
 22769  53
         Object EQUAL661_tree=null;
 22770  70
         Object CLOSE_BRACE663_tree=null;
 22771  53
         RewriteRuleTokenStream stream_SAMPLE=new RewriteRuleTokenStream(adaptor,"token SAMPLE");
 22772  70
         RewriteRuleTokenStream stream_AVG=new RewriteRuleTokenStream(adaptor,"token AVG");
 22773  53
         RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
 22774  53
         RewriteRuleTokenStream stream_GROUP_CONCAT=new RewriteRuleTokenStream(adaptor,"token GROUP_CONCAT");
 22775  59
         RewriteRuleTokenStream stream_MAX=new RewriteRuleTokenStream(adaptor,"token MAX");
 22776  53
         RewriteRuleTokenStream stream_COUNT=new RewriteRuleTokenStream(adaptor,"token COUNT");
 22777  59
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 22778  53
         RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
 22779  53
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 22780  60
         RewriteRuleTokenStream stream_MIN=new RewriteRuleTokenStream(adaptor,"token MIN");
 22781  53
         RewriteRuleTokenStream stream_SUM=new RewriteRuleTokenStream(adaptor,"token SUM");
 22782  60
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 22783  53
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 22784  53
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 22785  58
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22786  53
         RewriteRuleSubtreeStream stream_string=new RewriteRuleSubtreeStream(adaptor,"rule string");
 22787  5
         try {
 22788  
             // com\\googlecode\\sparkleg\\Sparql.g:613:5: ( COUNT OPEN_BRACE ( DISTINCT )? ( ASTERISK | expression ) CLOSE_BRACE -> ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* ) | SUM OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SUM ( DISTINCT )* expression ) | MIN OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MIN ( DISTINCT )* expression ) | MAX OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MAX ( DISTINCT )* expression ) | AVG OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( AVG ( DISTINCT )* expression ) | SAMPLE OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SAMPLE ( DISTINCT )? expression ) | GROUP_CONCAT OPEN_BRACE ( DISTINCT )? expression ( SEMICOLON SEPARATOR EQUAL string )? CLOSE_BRACE -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* ) )
 22789  53
             int alt138=7;
 22790  65
             switch ( input.LA(1) ) {
 22791  
             case COUNT:
 22792  12
                 {
 22793  17
                 alt138=1;
 22794  
                 }
 22795  20
                 break;
 22796  
             case SUM:
 22797  3
                 {
 22798  6
                 alt138=2;
 22799  
                 }
 22800  9
                 break;
 22801  
             case MIN:
 22802  3
                 {
 22803  7
                 alt138=3;
 22804  
                 }
 22805  7
                 break;
 22806  
             case MAX:
 22807  
                 {
 22808  5
                 alt138=4;
 22809  
                 }
 22810  5
                 break;
 22811  53
             case AVG:
 22812  
                 {
 22813  12
                 alt138=5;
 22814  
                 }
 22815  29
                 break;
 22816  17
             case SAMPLE:
 22817  
                 {
 22818  3
                 alt138=6;
 22819  17
                 }
 22820  20
                 break;
 22821  
             case GROUP_CONCAT:
 22822  
                 {
 22823  3
                 alt138=7;
 22824  17
                 }
 22825  20
                 break;
 22826  
             default:
 22827  0
                 NoViableAltException nvae =
 22828  
                     new NoViableAltException("", 138, 0, input);
 22829  
 
 22830  0
                 throw nvae;
 22831  
 
 22832  
             }
 22833  17
 
 22834  53
             switch (alt138) {
 22835  
                 case 1 :
 22836  
                     // com\\googlecode\\sparkleg\\Sparql.g:613:7: COUNT OPEN_BRACE ( DISTINCT )? ( ASTERISK | expression ) CLOSE_BRACE
 22837  
                     {
 22838  17
                     COUNT624=(Token)match(input,COUNT,FOLLOW_COUNT_in_aggregate6372);  
 22839  17
                     stream_COUNT.add(COUNT624);
 22840  
 
 22841  
 
 22842  17
                     OPEN_BRACE625=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6374);  
 22843  17
                     stream_OPEN_BRACE.add(OPEN_BRACE625);
 22844  
 
 22845  
 
 22846  
                     // com\\googlecode\\sparkleg\\Sparql.g:613:24: ( DISTINCT )?
 22847  17
                     int alt129=2;
 22848  34
                     switch ( input.LA(1) ) {
 22849  17
                         case DISTINCT:
 22850  
                             {
 22851  0
                             alt129=1;
 22852  7
                             }
 22853  
                             break;
 22854  7
                     }
 22855  
 
 22856  17
                     switch (alt129) {
 22857  
                         case 1 :
 22858  
                             // com\\googlecode\\sparkleg\\Sparql.g:613:24: DISTINCT
 22859  
                             {
 22860  0
                             DISTINCT626=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6376);  
 22861  0
                             stream_DISTINCT.add(DISTINCT626);
 22862  
 
 22863  
 
 22864  
                             }
 22865  
                             break;
 22866  
 
 22867  
                     }
 22868  
 
 22869  
 
 22870  
                     // com\\googlecode\\sparkleg\\Sparql.g:613:34: ( ASTERISK | expression )
 22871  17
                     int alt130=2;
 22872  17
                     switch ( input.LA(1) ) {
 22873  
                     case ASTERISK:
 22874  
                         {
 22875  7
                         alt130=1;
 22876  
                         }
 22877  7
                         break;
 22878  
                     case ABS:
 22879  
                     case AVG:
 22880  
                     case BNODE:
 22881  
                     case BOUND:
 22882  
                     case CEIL:
 22883  
                     case COALESCE:
 22884  
                     case CONCAT:
 22885  
                     case CONTAINS:
 22886  
                     case COUNT:
 22887  
                     case DATATYPE:
 22888  
                     case DAY:
 22889  
                     case DECIMAL:
 22890  
                     case DECIMAL_NEGATIVE:
 22891  
                     case DECIMAL_POSITIVE:
 22892  
                     case DOUBLE:
 22893  
                     case DOUBLE_NEGATIVE:
 22894  
                     case DOUBLE_POSITIVE:
 22895  
                     case ENCODE_FOR_URI:
 22896  
                     case EXISTS:
 22897  
                     case FALSE:
 22898  
                     case FLOOR:
 22899  
                     case GROUP_CONCAT:
 22900  
                     case HOURS:
 22901  
                     case IF:
 22902  
                     case INTEGER:
 22903  
                     case INTEGER_NEGATIVE:
 22904  
                     case INTEGER_POSITIVE:
 22905  
                     case IRI:
 22906  
                     case IRI_REF:
 22907  
                     case ISBLANK:
 22908  
                     case ISIRI:
 22909  
                     case ISLITERAL:
 22910  
                     case ISNUMERIC:
 22911  
                     case ISURI:
 22912  
                     case LANG:
 22913  
                     case LANGMATCHES:
 22914  
                     case LCASE:
 22915  
                     case MAX:
 22916  
                     case MD5:
 22917  
                     case MIN:
 22918  
                     case MINUS:
 22919  
                     case MINUTES:
 22920  
                     case MONTH:
 22921  
                     case NEGATION:
 22922  
                     case NOT:
 22923  
                     case NOW:
 22924  
                     case OPEN_BRACE:
 22925  
                     case PLUS:
 22926  
                     case PNAME_LN:
 22927  
                     case PNAME_NS:
 22928  
                     case RAND:
 22929  
                     case REGEX:
 22930  
                     case REPLACE:
 22931  
                     case ROUND:
 22932  
                     case SAMETERM:
 22933  
                     case SAMPLE:
 22934  
                     case SECONDS:
 22935  
                     case SHA1:
 22936  
                     case SHA224:
 22937  
                     case SHA256:
 22938  
                     case SHA384:
 22939  
                     case SHA512:
 22940  10
                     case STR:
 22941  
                     case STRAFTER:
 22942  10
                     case STRBEFORE:
 22943  
                     case STRDT:
 22944  
                     case STRENDS:
 22945  
                     case STRING_LITERAL1:
 22946  
                     case STRING_LITERAL2:
 22947  
                     case STRING_LITERAL_LONG1:
 22948  
                     case STRING_LITERAL_LONG2:
 22949  
                     case STRLANG:
 22950  
                     case STRLEN:
 22951  17
                     case STRSTARTS:
 22952  
                     case SUBSTR:
 22953  
                     case SUM:
 22954  
                     case TIMEZONE:
 22955  7
                     case TRUE:
 22956  7
                     case TZ:
 22957  
                     case UCASE:
 22958  
                     case URI:
 22959  
                     case VAR1:
 22960  7
                     case VAR2:
 22961  
                     case YEAR:
 22962  
                         {
 22963  10
                         alt130=2;
 22964  10
                         }
 22965  20
                         break;
 22966  
                     default:
 22967  10
                         NoViableAltException nvae =
 22968  
                             new NoViableAltException("", 130, 0, input);
 22969  10
 
 22970  0
                         throw nvae;
 22971  
 
 22972  
                     }
 22973  
 
 22974  17
                     switch (alt130) {
 22975  
                         case 1 :
 22976  
                             // com\\googlecode\\sparkleg\\Sparql.g:613:35: ASTERISK
 22977  17
                             {
 22978  24
                             ASTERISK627=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_aggregate6380);  
 22979  7
                             stream_ASTERISK.add(ASTERISK627);
 22980  
 
 22981  
 
 22982  
                             }
 22983  7
                             break;
 22984  
                         case 2 :
 22985  
                             // com\\googlecode\\sparkleg\\Sparql.g:613:46: expression
 22986  
                             {
 22987  10
                             pushFollow(FOLLOW_expression_in_aggregate6384);
 22988  27
                             expression628=expression();
 22989  17
 
 22990  10
                             state._fsp--;
 22991  17
 
 22992  10
                             stream_expression.add(expression628.getTree());
 22993  
 
 22994  
                             }
 22995  
                             break;
 22996  17
 
 22997  17
                     }
 22998  
 
 22999  
 
 23000  17
                     CLOSE_BRACE629=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6387);  
 23001  17
                     stream_CLOSE_BRACE.add(CLOSE_BRACE629);
 23002  17
 
 23003  
 
 23004  
                     // AST REWRITE
 23005  
                     // elements: DISTINCT, COUNT, expression, ASTERISK
 23006  
                     // token labels: 
 23007  
                     // rule labels: retval
 23008  17
                     // token list labels: 
 23009  
                     // rule list labels: 
 23010  
                     // wildcard labels: 
 23011  41
                     retval.tree = root_0;
 23012  24
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23013  
 
 23014  17
                     root_0 = (Object)adaptor.nil();
 23015  
                     // 613:70: -> ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* )
 23016  
                     {
 23017  17
                         // com\\googlecode\\sparkleg\\Sparql.g:613:73: ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* )
 23018  
                         {
 23019  17
                         Object root_1 = (Object)adaptor.nil();
 23020  44
                         root_1 = (Object)adaptor.becomeRoot(
 23021  10
                         stream_COUNT.nextNode()
 23022  
                         , root_1);
 23023  
 
 23024  17
                         // com\\googlecode\\sparkleg\\Sparql.g:613:81: ( DISTINCT )*
 23025  17
                         while ( stream_DISTINCT.hasNext() ) {
 23026  17
                             adaptor.addChild(root_1, 
 23027  
                             stream_DISTINCT.nextNode()
 23028  
                             );
 23029  
 
 23030  
                         }
 23031  17
                         stream_DISTINCT.reset();
 23032  17
 
 23033  
                         // com\\googlecode\\sparkleg\\Sparql.g:613:91: ( ASTERISK )*
 23034  24
                         while ( stream_ASTERISK.hasNext() ) {
 23035  24
                             adaptor.addChild(root_1, 
 23036  
                             stream_ASTERISK.nextNode()
 23037  
                             );
 23038  
 
 23039  6
                         }
 23040  23
                         stream_ASTERISK.reset();
 23041  
 
 23042  
                         // com\\googlecode\\sparkleg\\Sparql.g:613:101: ( expression )*
 23043  33
                         while ( stream_expression.hasNext() ) {
 23044  16
                             adaptor.addChild(root_1, stream_expression.nextTree());
 23045  
 
 23046  
                         }
 23047  17
                         stream_expression.reset();
 23048  6
 
 23049  23
                         adaptor.addChild(root_0, root_1);
 23050  
                         }
 23051  
 
 23052  
                     }
 23053  
 
 23054  
 
 23055  17
                     retval.tree = root_0;
 23056  
 
 23057  6
                     }
 23058  17
                     break;
 23059  
                 case 2 :
 23060  
                     // com\\googlecode\\sparkleg\\Sparql.g:614:7: SUM OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23061  
                     {
 23062  6
                     SUM630=(Token)match(input,SUM,FOLLOW_SUM_in_aggregate6410);  
 23063  6
                     stream_SUM.add(SUM630);
 23064  
 
 23065  
 
 23066  6
                     OPEN_BRACE631=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6412);  
 23067  6
                     stream_OPEN_BRACE.add(OPEN_BRACE631);
 23068  
 
 23069  
 
 23070  
                     // com\\googlecode\\sparkleg\\Sparql.g:614:22: ( DISTINCT )?
 23071  12
                     int alt131=2;
 23072  12
                     switch ( input.LA(1) ) {
 23073  
                         case DISTINCT:
 23074  6
                             {
 23075  0
                             alt131=1;
 23076  6
                             }
 23077  
                             break;
 23078  6
                     }
 23079  6
 
 23080  6
                     switch (alt131) {
 23081  
                         case 1 :
 23082  
                             // com\\googlecode\\sparkleg\\Sparql.g:614:22: DISTINCT
 23083  
                             {
 23084  0
                             DISTINCT632=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6414);  
 23085  0
                             stream_DISTINCT.add(DISTINCT632);
 23086  
 
 23087  
 
 23088  
                             }
 23089  6
                             break;
 23090  6
 
 23091  
                     }
 23092  6
 
 23093  
 
 23094  6
                     pushFollow(FOLLOW_expression_in_aggregate6417);
 23095  6
                     expression633=expression();
 23096  
 
 23097  12
                     state._fsp--;
 23098  6
 
 23099  6
                     stream_expression.add(expression633.getTree());
 23100  
 
 23101  6
                     CLOSE_BRACE634=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6419);  
 23102  6
                     stream_CLOSE_BRACE.add(CLOSE_BRACE634);
 23103  6
 
 23104  
 
 23105  
                     // AST REWRITE
 23106  
                     // elements: expression, DISTINCT, SUM
 23107  
                     // token labels: 
 23108  
                     // rule labels: retval
 23109  6
                     // token list labels: 
 23110  
                     // rule list labels: 
 23111  6
                     // wildcard labels: 
 23112  6
                     retval.tree = root_0;
 23113  12
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23114  
 
 23115  6
                     root_0 = (Object)adaptor.nil();
 23116  
                     // 614:55: -> ^( SUM ( DISTINCT )* expression )
 23117  
                     {
 23118  
                         // com\\googlecode\\sparkleg\\Sparql.g:614:58: ^( SUM ( DISTINCT )* expression )
 23119  6
                         {
 23120  6
                         Object root_1 = (Object)adaptor.nil();
 23121  6
                         root_1 = (Object)adaptor.becomeRoot(
 23122  6
                         stream_SUM.nextNode()
 23123  
                         , root_1);
 23124  
 
 23125  
                         // com\\googlecode\\sparkleg\\Sparql.g:614:64: ( DISTINCT )*
 23126  13
                         while ( stream_DISTINCT.hasNext() ) {
 23127  7
                             adaptor.addChild(root_1, 
 23128  
                             stream_DISTINCT.nextNode()
 23129  
                             );
 23130  7
 
 23131  7
                         }
 23132  6
                         stream_DISTINCT.reset();
 23133  
 
 23134  6
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23135  7
 
 23136  13
                         adaptor.addChild(root_0, root_1);
 23137  
                         }
 23138  
 
 23139  
                     }
 23140  
 
 23141  
 
 23142  6
                     retval.tree = root_0;
 23143  
 
 23144  7
                     }
 23145  6
                     break;
 23146  
                 case 3 :
 23147  
                     // com\\googlecode\\sparkleg\\Sparql.g:615:7: MIN OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23148  
                     {
 23149  7
                     MIN635=(Token)match(input,MIN,FOLLOW_MIN_in_aggregate6438);  
 23150  7
                     stream_MIN.add(MIN635);
 23151  
 
 23152  
 
 23153  7
                     OPEN_BRACE636=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6440);  
 23154  7
                     stream_OPEN_BRACE.add(OPEN_BRACE636);
 23155  
 
 23156  
 
 23157  
                     // com\\googlecode\\sparkleg\\Sparql.g:615:22: ( DISTINCT )?
 23158  14
                     int alt132=2;
 23159  14
                     switch ( input.LA(1) ) {
 23160  
                         case DISTINCT:
 23161  7
                             {
 23162  0
                             alt132=1;
 23163  7
                             }
 23164  
                             break;
 23165  7
                     }
 23166  7
 
 23167  7
                     switch (alt132) {
 23168  
                         case 1 :
 23169  
                             // com\\googlecode\\sparkleg\\Sparql.g:615:22: DISTINCT
 23170  
                             {
 23171  0
                             DISTINCT637=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6442);  
 23172  0
                             stream_DISTINCT.add(DISTINCT637);
 23173  
 
 23174  
 
 23175  
                             }
 23176  7
                             break;
 23177  7
 
 23178  
                     }
 23179  7
 
 23180  
 
 23181  7
                     pushFollow(FOLLOW_expression_in_aggregate6445);
 23182  7
                     expression638=expression();
 23183  
 
 23184  14
                     state._fsp--;
 23185  7
 
 23186  7
                     stream_expression.add(expression638.getTree());
 23187  
 
 23188  7
                     CLOSE_BRACE639=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6447);  
 23189  7
                     stream_CLOSE_BRACE.add(CLOSE_BRACE639);
 23190  7
 
 23191  
 
 23192  
                     // AST REWRITE
 23193  
                     // elements: DISTINCT, MIN, expression
 23194  
                     // token labels: 
 23195  
                     // rule labels: retval
 23196  7
                     // token list labels: 
 23197  
                     // rule list labels: 
 23198  7
                     // wildcard labels: 
 23199  7
                     retval.tree = root_0;
 23200  14
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23201  
 
 23202  7
                     root_0 = (Object)adaptor.nil();
 23203  
                     // 615:55: -> ^( MIN ( DISTINCT )* expression )
 23204  
                     {
 23205  
                         // com\\googlecode\\sparkleg\\Sparql.g:615:58: ^( MIN ( DISTINCT )* expression )
 23206  7
                         {
 23207  7
                         Object root_1 = (Object)adaptor.nil();
 23208  7
                         root_1 = (Object)adaptor.becomeRoot(
 23209  7
                         stream_MIN.nextNode()
 23210  
                         , root_1);
 23211  
 
 23212  
                         // com\\googlecode\\sparkleg\\Sparql.g:615:64: ( DISTINCT )*
 23213  12
                         while ( stream_DISTINCT.hasNext() ) {
 23214  5
                             adaptor.addChild(root_1, 
 23215  
                             stream_DISTINCT.nextNode()
 23216  
                             );
 23217  5
 
 23218  5
                         }
 23219  7
                         stream_DISTINCT.reset();
 23220  
 
 23221  7
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23222  5
 
 23223  12
                         adaptor.addChild(root_0, root_1);
 23224  
                         }
 23225  
 
 23226  
                     }
 23227  
 
 23228  
 
 23229  7
                     retval.tree = root_0;
 23230  
 
 23231  5
                     }
 23232  7
                     break;
 23233  
                 case 4 :
 23234  
                     // com\\googlecode\\sparkleg\\Sparql.g:616:7: MAX OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23235  
                     {
 23236  5
                     MAX640=(Token)match(input,MAX,FOLLOW_MAX_in_aggregate6466);  
 23237  5
                     stream_MAX.add(MAX640);
 23238  
 
 23239  
 
 23240  5
                     OPEN_BRACE641=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6468);  
 23241  5
                     stream_OPEN_BRACE.add(OPEN_BRACE641);
 23242  
 
 23243  
 
 23244  
                     // com\\googlecode\\sparkleg\\Sparql.g:616:22: ( DISTINCT )?
 23245  10
                     int alt133=2;
 23246  10
                     switch ( input.LA(1) ) {
 23247  
                         case DISTINCT:
 23248  5
                             {
 23249  0
                             alt133=1;
 23250  5
                             }
 23251  
                             break;
 23252  5
                     }
 23253  5
 
 23254  5
                     switch (alt133) {
 23255  
                         case 1 :
 23256  
                             // com\\googlecode\\sparkleg\\Sparql.g:616:22: DISTINCT
 23257  
                             {
 23258  0
                             DISTINCT642=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6470);  
 23259  0
                             stream_DISTINCT.add(DISTINCT642);
 23260  
 
 23261  
 
 23262  
                             }
 23263  5
                             break;
 23264  5
 
 23265  
                     }
 23266  5
 
 23267  
 
 23268  5
                     pushFollow(FOLLOW_expression_in_aggregate6473);
 23269  5
                     expression643=expression();
 23270  
 
 23271  10
                     state._fsp--;
 23272  5
 
 23273  5
                     stream_expression.add(expression643.getTree());
 23274  
 
 23275  5
                     CLOSE_BRACE644=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6475);  
 23276  5
                     stream_CLOSE_BRACE.add(CLOSE_BRACE644);
 23277  5
 
 23278  
 
 23279  
                     // AST REWRITE
 23280  
                     // elements: expression, DISTINCT, MAX
 23281  
                     // token labels: 
 23282  
                     // rule labels: retval
 23283  5
                     // token list labels: 
 23284  
                     // rule list labels: 
 23285  5
                     // wildcard labels: 
 23286  5
                     retval.tree = root_0;
 23287  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23288  
 
 23289  5
                     root_0 = (Object)adaptor.nil();
 23290  
                     // 616:55: -> ^( MAX ( DISTINCT )* expression )
 23291  
                     {
 23292  
                         // com\\googlecode\\sparkleg\\Sparql.g:616:58: ^( MAX ( DISTINCT )* expression )
 23293  5
                         {
 23294  5
                         Object root_1 = (Object)adaptor.nil();
 23295  5
                         root_1 = (Object)adaptor.becomeRoot(
 23296  5
                         stream_MAX.nextNode()
 23297  
                         , root_1);
 23298  
 
 23299  
                         // com\\googlecode\\sparkleg\\Sparql.g:616:64: ( DISTINCT )*
 23300  17
                         while ( stream_DISTINCT.hasNext() ) {
 23301  12
                             adaptor.addChild(root_1, 
 23302  
                             stream_DISTINCT.nextNode()
 23303  
                             );
 23304  12
 
 23305  12
                         }
 23306  5
                         stream_DISTINCT.reset();
 23307  
 
 23308  5
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23309  12
 
 23310  17
                         adaptor.addChild(root_0, root_1);
 23311  
                         }
 23312  
 
 23313  
                     }
 23314  
 
 23315  
 
 23316  5
                     retval.tree = root_0;
 23317  
 
 23318  12
                     }
 23319  5
                     break;
 23320  
                 case 5 :
 23321  
                     // com\\googlecode\\sparkleg\\Sparql.g:617:7: AVG OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23322  
                     {
 23323  12
                     AVG645=(Token)match(input,AVG,FOLLOW_AVG_in_aggregate6494);  
 23324  12
                     stream_AVG.add(AVG645);
 23325  
 
 23326  
 
 23327  12
                     OPEN_BRACE646=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6496);  
 23328  12
                     stream_OPEN_BRACE.add(OPEN_BRACE646);
 23329  
 
 23330  
 
 23331  
                     // com\\googlecode\\sparkleg\\Sparql.g:617:22: ( DISTINCT )?
 23332  24
                     int alt134=2;
 23333  24
                     switch ( input.LA(1) ) {
 23334  
                         case DISTINCT:
 23335  12
                             {
 23336  0
                             alt134=1;
 23337  12
                             }
 23338  
                             break;
 23339  12
                     }
 23340  12
 
 23341  12
                     switch (alt134) {
 23342  
                         case 1 :
 23343  
                             // com\\googlecode\\sparkleg\\Sparql.g:617:22: DISTINCT
 23344  
                             {
 23345  0
                             DISTINCT647=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6498);  
 23346  0
                             stream_DISTINCT.add(DISTINCT647);
 23347  
 
 23348  
 
 23349  
                             }
 23350  12
                             break;
 23351  12
 
 23352  
                     }
 23353  12
 
 23354  
 
 23355  12
                     pushFollow(FOLLOW_expression_in_aggregate6501);
 23356  12
                     expression648=expression();
 23357  
 
 23358  24
                     state._fsp--;
 23359  12
 
 23360  12
                     stream_expression.add(expression648.getTree());
 23361  
 
 23362  12
                     CLOSE_BRACE649=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6503);  
 23363  12
                     stream_CLOSE_BRACE.add(CLOSE_BRACE649);
 23364  12
 
 23365  
 
 23366  
                     // AST REWRITE
 23367  
                     // elements: AVG, expression, DISTINCT
 23368  
                     // token labels: 
 23369  
                     // rule labels: retval
 23370  12
                     // token list labels: 
 23371  
                     // rule list labels: 
 23372  12
                     // wildcard labels: 
 23373  12
                     retval.tree = root_0;
 23374  24
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23375  
 
 23376  12
                     root_0 = (Object)adaptor.nil();
 23377  
                     // 617:55: -> ^( AVG ( DISTINCT )* expression )
 23378  
                     {
 23379  
                         // com\\googlecode\\sparkleg\\Sparql.g:617:58: ^( AVG ( DISTINCT )* expression )
 23380  12
                         {
 23381  12
                         Object root_1 = (Object)adaptor.nil();
 23382  12
                         root_1 = (Object)adaptor.becomeRoot(
 23383  12
                         stream_AVG.nextNode()
 23384  
                         , root_1);
 23385  
 
 23386  
                         // com\\googlecode\\sparkleg\\Sparql.g:617:64: ( DISTINCT )*
 23387  15
                         while ( stream_DISTINCT.hasNext() ) {
 23388  3
                             adaptor.addChild(root_1, 
 23389  
                             stream_DISTINCT.nextNode()
 23390  
                             );
 23391  3
 
 23392  3
                         }
 23393  12
                         stream_DISTINCT.reset();
 23394  
 
 23395  12
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23396  3
 
 23397  15
                         adaptor.addChild(root_0, root_1);
 23398  
                         }
 23399  
 
 23400  
                     }
 23401  
 
 23402  
 
 23403  12
                     retval.tree = root_0;
 23404  
 
 23405  3
                     }
 23406  12
                     break;
 23407  
                 case 6 :
 23408  
                     // com\\googlecode\\sparkleg\\Sparql.g:618:7: SAMPLE OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23409  
                     {
 23410  3
                     SAMPLE650=(Token)match(input,SAMPLE,FOLLOW_SAMPLE_in_aggregate6522);  
 23411  3
                     stream_SAMPLE.add(SAMPLE650);
 23412  
 
 23413  
 
 23414  3
                     OPEN_BRACE651=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6524);  
 23415  3
                     stream_OPEN_BRACE.add(OPEN_BRACE651);
 23416  
 
 23417  
 
 23418  
                     // com\\googlecode\\sparkleg\\Sparql.g:618:25: ( DISTINCT )?
 23419  6
                     int alt135=2;
 23420  6
                     switch ( input.LA(1) ) {
 23421  
                         case DISTINCT:
 23422  3
                             {
 23423  0
                             alt135=1;
 23424  3
                             }
 23425  
                             break;
 23426  3
                     }
 23427  3
 
 23428  3
                     switch (alt135) {
 23429  
                         case 1 :
 23430  
                             // com\\googlecode\\sparkleg\\Sparql.g:618:25: DISTINCT
 23431  
                             {
 23432  0
                             DISTINCT652=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6526);  
 23433  0
                             stream_DISTINCT.add(DISTINCT652);
 23434  
 
 23435  
 
 23436  
                             }
 23437  3
                             break;
 23438  3
 
 23439  
                     }
 23440  3
 
 23441  
 
 23442  3
                     pushFollow(FOLLOW_expression_in_aggregate6529);
 23443  3
                     expression653=expression();
 23444  
 
 23445  6
                     state._fsp--;
 23446  3
 
 23447  3
                     stream_expression.add(expression653.getTree());
 23448  
 
 23449  3
                     CLOSE_BRACE654=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6531);  
 23450  3
                     stream_CLOSE_BRACE.add(CLOSE_BRACE654);
 23451  3
 
 23452  
 
 23453  
                     // AST REWRITE
 23454  
                     // elements: DISTINCT, expression, SAMPLE
 23455  
                     // token labels: 
 23456  
                     // rule labels: retval
 23457  3
                     // token list labels: 
 23458  
                     // rule list labels: 
 23459  3
                     // wildcard labels: 
 23460  3
                     retval.tree = root_0;
 23461  6
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23462  
 
 23463  3
                     root_0 = (Object)adaptor.nil();
 23464  
                     // 618:58: -> ^( SAMPLE ( DISTINCT )? expression )
 23465  
                     {
 23466  
                         // com\\googlecode\\sparkleg\\Sparql.g:618:61: ^( SAMPLE ( DISTINCT )? expression )
 23467  3
                         {
 23468  3
                         Object root_1 = (Object)adaptor.nil();
 23469  3
                         root_1 = (Object)adaptor.becomeRoot(
 23470  3
                         stream_SAMPLE.nextNode()
 23471  
                         , root_1);
 23472  
 
 23473  
                         // com\\googlecode\\sparkleg\\Sparql.g:618:70: ( DISTINCT )?
 23474  6
                         if ( stream_DISTINCT.hasNext() ) {
 23475  3
                             adaptor.addChild(root_1, 
 23476  
                             stream_DISTINCT.nextNode()
 23477  
                             );
 23478  3
 
 23479  3
                         }
 23480  3
                         stream_DISTINCT.reset();
 23481  
 
 23482  3
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23483  3
 
 23484  6
                         adaptor.addChild(root_0, root_1);
 23485  
                         }
 23486  
 
 23487  
                     }
 23488  
 
 23489  
 
 23490  3
                     retval.tree = root_0;
 23491  
 
 23492  3
                     }
 23493  3
                     break;
 23494  
                 case 7 :
 23495  
                     // com\\googlecode\\sparkleg\\Sparql.g:619:7: GROUP_CONCAT OPEN_BRACE ( DISTINCT )? expression ( SEMICOLON SEPARATOR EQUAL string )? CLOSE_BRACE
 23496  
                     {
 23497  3
                     GROUP_CONCAT655=(Token)match(input,GROUP_CONCAT,FOLLOW_GROUP_CONCAT_in_aggregate6550);  
 23498  3
                     stream_GROUP_CONCAT.add(GROUP_CONCAT655);
 23499  
 
 23500  
 
 23501  3
                     OPEN_BRACE656=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6552);  
 23502  3
                     stream_OPEN_BRACE.add(OPEN_BRACE656);
 23503  
 
 23504  
 
 23505  
                     // com\\googlecode\\sparkleg\\Sparql.g:619:31: ( DISTINCT )?
 23506  6
                     int alt136=2;
 23507  6
                     switch ( input.LA(1) ) {
 23508  
                         case DISTINCT:
 23509  3
                             {
 23510  0
                             alt136=1;
 23511  3
                             }
 23512  
                             break;
 23513  
                     }
 23514  3
 
 23515  6
                     switch (alt136) {
 23516  
                         case 1 :
 23517  
                             // com\\googlecode\\sparkleg\\Sparql.g:619:31: DISTINCT
 23518  1
                             {
 23519  0
                             DISTINCT657=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6554);  
 23520  0
                             stream_DISTINCT.add(DISTINCT657);
 23521  
 
 23522  
 
 23523  3
                             }
 23524  
                             break;
 23525  
 
 23526  
                     }
 23527  1
 
 23528  1
 
 23529  3
                     pushFollow(FOLLOW_expression_in_aggregate6557);
 23530  3
                     expression658=expression();
 23531  1
 
 23532  4
                     state._fsp--;
 23533  
 
 23534  3
                     stream_expression.add(expression658.getTree());
 23535  1
 
 23536  1
                     // com\\googlecode\\sparkleg\\Sparql.g:619:52: ( SEMICOLON SEPARATOR EQUAL string )?
 23537  3
                     int alt137=2;
 23538  3
                     switch ( input.LA(1) ) {
 23539  1
                         case SEMICOLON:
 23540  1
                             {
 23541  1
                             alt137=1;
 23542  1
                             }
 23543  
                             break;
 23544  1
                     }
 23545  
 
 23546  3
                     switch (alt137) {
 23547  
                         case 1 :
 23548  
                             // com\\googlecode\\sparkleg\\Sparql.g:619:53: SEMICOLON SEPARATOR EQUAL string
 23549  
                             {
 23550  1
                             SEMICOLON659=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_aggregate6560);  
 23551  1
                             stream_SEMICOLON.add(SEMICOLON659);
 23552  3
 
 23553  3
 
 23554  1
                             SEPARATOR660=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_aggregate6562);  
 23555  1
                             stream_SEPARATOR.add(SEPARATOR660);
 23556  
 
 23557  
 
 23558  1
                             EQUAL661=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_aggregate6564);  
 23559  1
                             stream_EQUAL.add(EQUAL661);
 23560  
 
 23561  
 
 23562  1
                             pushFollow(FOLLOW_string_in_aggregate6566);
 23563  4
                             string662=string();
 23564  3
 
 23565  1
                             state._fsp--;
 23566  3
 
 23567  1
                             stream_string.add(string662.getTree());
 23568  
 
 23569  
                             }
 23570  
                             break;
 23571  3
 
 23572  3
                     }
 23573  
 
 23574  
 
 23575  3
                     CLOSE_BRACE663=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6570);  
 23576  3
                     stream_CLOSE_BRACE.add(CLOSE_BRACE663);
 23577  3
 
 23578  
 
 23579  
                     // AST REWRITE
 23580  
                     // elements: DISTINCT, string, expression, GROUP_CONCAT
 23581  
                     // token labels: 
 23582  
                     // rule labels: retval
 23583  3
                     // token list labels: 
 23584  
                     // rule list labels: 
 23585  3
                     // wildcard labels: 
 23586  3
                     retval.tree = root_0;
 23587  3
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23588  4
 
 23589  4
                     root_0 = (Object)adaptor.nil();
 23590  
                     // 619:100: -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* )
 23591  
                     {
 23592  3
                         // com\\googlecode\\sparkleg\\Sparql.g:619:103: ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* )
 23593  
                         {
 23594  6
                         Object root_1 = (Object)adaptor.nil();
 23595  3
                         root_1 = (Object)adaptor.becomeRoot(
 23596  
                         stream_GROUP_CONCAT.nextNode()
 23597  
                         , root_1);
 23598  
 
 23599  
                         // com\\googlecode\\sparkleg\\Sparql.g:619:118: ( DISTINCT )*
 23600  6
                         while ( stream_DISTINCT.hasNext() ) {
 23601  0
                             adaptor.addChild(root_1, 
 23602  
                             stream_DISTINCT.nextNode()
 23603  
                             );
 23604  
 
 23605  
                         }
 23606  56
                         stream_DISTINCT.reset();
 23607  
 
 23608  3
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23609  53
 
 23610  53
                         // com\\googlecode\\sparkleg\\Sparql.g:619:139: ( string )*
 23611  4
                         while ( stream_string.hasNext() ) {
 23612  1
                             adaptor.addChild(root_1, stream_string.nextTree());
 23613  
 
 23614  
                         }
 23615  3
                         stream_string.reset();
 23616  
 
 23617  3
                         adaptor.addChild(root_0, root_1);
 23618  
                         }
 23619  
 
 23620  
                     }
 23621  
 
 23622  53
 
 23623  56
                     retval.tree = root_0;
 23624  
 
 23625  
                     }
 23626  
                     break;
 23627  
 
 23628  89
             }
 23629  53
             retval.stop = input.LT(-1);
 23630  89
 
 23631  
 
 23632  53
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 23633  53
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 23634  
 
 23635  
         }
 23636  0
         catch (RecognitionException re) {
 23637  89
             reportError(re);
 23638  89
             recover(input,re);
 23639  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 23640  
 
 23641  89
         }
 23642  
 
 23643  89
         finally {
 23644  
                 // do for sure before leaving
 23645  142
         }
 23646  53
         return retval;
 23647  
     }
 23648  89
     // $ANTLR end "aggregate"
 23649  89
 
 23650  
 
 23651  89
     public static class iriRefOrFunction_return extends ParserRuleReturnScope {
 23652  
         Object tree;
 23653  89
         public Object getTree() { return tree; }
 23654  89
     };
 23655  89
 
 23656  
 
 23657  89
     // $ANTLR start "iriRefOrFunction"
 23658  
     // com\\googlecode\\sparkleg\\Sparql.g:622:1: iriRefOrFunction : iriRef ( argList )? -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? ) ;
 23659  89
     public final SparqlParser.iriRefOrFunction_return iriRefOrFunction() throws RecognitionException {
 23660  89
         SparqlParser.iriRefOrFunction_return retval = new SparqlParser.iriRefOrFunction_return();
 23661  89
         retval.start = input.LT(1);
 23662  89
 
 23663  89
 
 23664  89
         Object root_0 = null;
 23665  
 
 23666  113
         SparqlParser.iriRef_return iriRef664 =null;
 23667  
 
 23668  89
         SparqlParser.argList_return argList665 =null;
 23669  
 
 23670  
 
 23671  178
         RewriteRuleSubtreeStream stream_argList=new RewriteRuleSubtreeStream(adaptor,"rule argList");
 23672  89
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 23673  
         try {
 23674  
             // com\\googlecode\\sparkleg\\Sparql.g:623:5: ( iriRef ( argList )? -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? ) )
 23675  24
             // com\\googlecode\\sparkleg\\Sparql.g:623:7: iriRef ( argList )?
 23676  24
             {
 23677  89
             pushFollow(FOLLOW_iriRef_in_iriRefOrFunction6605);
 23678  113
             iriRef664=iriRef();
 23679  
 
 23680  113
             state._fsp--;
 23681  
 
 23682  89
             stream_iriRef.add(iriRef664.getTree());
 23683  
 
 23684  
             // com\\googlecode\\sparkleg\\Sparql.g:623:14: ( argList )?
 23685  89
             int alt139=2;
 23686  89
             switch ( input.LA(1) ) {
 23687  
                 case OPEN_BRACE:
 23688  
                     {
 23689  24
                     alt139=1;
 23690  
                     }
 23691  
                     break;
 23692  
             }
 23693  
 
 23694  89
             switch (alt139) {
 23695  89
                 case 1 :
 23696  89
                     // com\\googlecode\\sparkleg\\Sparql.g:623:14: argList
 23697  
                     {
 23698  113
                     pushFollow(FOLLOW_argList_in_iriRefOrFunction6607);
 23699  24
                     argList665=argList();
 23700  
 
 23701  24
                     state._fsp--;
 23702  
 
 23703  113
                     stream_argList.add(argList665.getTree());
 23704  89
 
 23705  
                     }
 23706  
                     break;
 23707  
 
 23708  89
             }
 23709  
 
 23710  
 
 23711  89
             // AST REWRITE
 23712  
             // elements: argList, iriRef
 23713  
             // token labels: 
 23714  24
             // rule labels: retval
 23715  24
             // token list labels: 
 23716  
             // rule list labels: 
 23717  
             // wildcard labels: 
 23718  89
             retval.tree = root_0;
 23719  113
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23720  
 
 23721  113
             root_0 = (Object)adaptor.nil();
 23722  
             // 623:23: -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? )
 23723  
             {
 23724  
                 // com\\googlecode\\sparkleg\\Sparql.g:623:26: ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? )
 23725  89
                 {
 23726  89
                 Object root_1 = (Object)adaptor.nil();
 23727  178
                 root_1 = (Object)adaptor.becomeRoot(
 23728  
                 (Object)adaptor.create(FUNCTION, "FUNCTION")
 23729  
                 , root_1);
 23730  
 
 23731  89
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 23732  
 
 23733  89
                 // com\\googlecode\\sparkleg\\Sparql.g:623:44: ( ^( ARG_LIST argList ) )?
 23734  89
                 if ( stream_argList.hasNext() ) {
 23735  
                     // com\\googlecode\\sparkleg\\Sparql.g:623:44: ^( ARG_LIST argList )
 23736  
                     {
 23737  113
                     Object root_2 = (Object)adaptor.nil();
 23738  24
                     root_2 = (Object)adaptor.becomeRoot(
 23739  
                     (Object)adaptor.create(ARG_LIST, "ARG_LIST")
 23740  89
                     , root_2);
 23741  89
 
 23742  24
                     adaptor.addChild(root_2, stream_argList.nextTree());
 23743  
 
 23744  24
                     adaptor.addChild(root_1, root_2);
 23745  
                     }
 23746  
 
 23747  
                 }
 23748  89
                 stream_argList.reset();
 23749  
 
 23750  89
                 adaptor.addChild(root_0, root_1);
 23751  
                 }
 23752  
 
 23753  89
             }
 23754  89
 
 23755  
 
 23756  89
             retval.tree = root_0;
 23757  
 
 23758  
             }
 23759  189
 
 23760  89
             retval.stop = input.LT(-1);
 23761  189
 
 23762  
 
 23763  89
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 23764  89
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 23765  
 
 23766  
         }
 23767  0
         catch (RecognitionException re) {
 23768  189
             reportError(re);
 23769  189
             recover(input,re);
 23770  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 23771  
 
 23772  189
         }
 23773  
 
 23774  189
         finally {
 23775  189
                 // do for sure before leaving
 23776  278
         }
 23777  89
         return retval;
 23778  189
     }
 23779  
     // $ANTLR end "iriRefOrFunction"
 23780  
 
 23781  189
 
 23782  189
     public static class rdfLiteral_return extends ParserRuleReturnScope {
 23783  
         Object tree;
 23784  189
         public Object getTree() { return tree; }
 23785  
     };
 23786  
 
 23787  
 
 23788  189
     // $ANTLR start "rdfLiteral"
 23789  
     // com\\googlecode\\sparkleg\\Sparql.g:626:1: rdfLiteral : string ( LANGTAG | ( REFERENCE iriRef ) )? ;
 23790  
     public final SparqlParser.rdfLiteral_return rdfLiteral() throws RecognitionException {
 23791  378
         SparqlParser.rdfLiteral_return retval = new SparqlParser.rdfLiteral_return();
 23792  378
         retval.start = input.LT(1);
 23793  
 
 23794  189
 
 23795  189
         Object root_0 = null;
 23796  189
 
 23797  189
         Token LANGTAG667=null;
 23798  189
         Token REFERENCE668=null;
 23799  378
         SparqlParser.string_return string666 =null;
 23800  189
 
 23801  189
         SparqlParser.iriRef_return iriRef669 =null;
 23802  
 
 23803  5
 
 23804  189
         Object LANGTAG667_tree=null;
 23805  194
         Object REFERENCE668_tree=null;
 23806  
 
 23807  
         try {
 23808  19
             // com\\googlecode\\sparkleg\\Sparql.g:627:5: ( string ( LANGTAG | ( REFERENCE iriRef ) )? )
 23809  
             // com\\googlecode\\sparkleg\\Sparql.g:627:7: string ( LANGTAG | ( REFERENCE iriRef ) )?
 23810  
             {
 23811  189
             root_0 = (Object)adaptor.nil();
 23812  
 
 23813  189
 
 23814  189
             pushFollow(FOLLOW_string_in_rdfLiteral6640);
 23815  189
             string666=string();
 23816  
 
 23817  194
             state._fsp--;
 23818  5
 
 23819  189
             adaptor.addChild(root_0, string666.getTree());
 23820  
 
 23821  5
             // com\\googlecode\\sparkleg\\Sparql.g:627:14: ( LANGTAG | ( REFERENCE iriRef ) )?
 23822  189
             int alt140=3;
 23823  189
             switch ( input.LA(1) ) {
 23824  
                 case LANGTAG:
 23825  5
                     {
 23826  5
                     alt140=1;
 23827  
                     }
 23828  5
                     break;
 23829  
                 case REFERENCE:
 23830  
                     {
 23831  19
                     alt140=2;
 23832  19
                     }
 23833  19
                     break;
 23834  
             }
 23835  
 
 23836  208
             switch (alt140) {
 23837  
                 case 1 :
 23838  
                     // com\\googlecode\\sparkleg\\Sparql.g:627:15: LANGTAG
 23839  19
                     {
 23840  24
                     LANGTAG667=(Token)match(input,LANGTAG,FOLLOW_LANGTAG_in_rdfLiteral6643); 
 23841  5
                     LANGTAG667_tree = 
 23842  19
                     (Object)adaptor.create(LANGTAG667)
 23843  
                     ;
 23844  24
                     adaptor.addChild(root_0, LANGTAG667_tree);
 23845  
 
 23846  
 
 23847  
                     }
 23848  5
                     break;
 23849  
                 case 2 :
 23850  
                     // com\\googlecode\\sparkleg\\Sparql.g:627:25: ( REFERENCE iriRef )
 23851  
                     {
 23852  
                     // com\\googlecode\\sparkleg\\Sparql.g:627:25: ( REFERENCE iriRef )
 23853  
                     // com\\googlecode\\sparkleg\\Sparql.g:627:26: REFERENCE iriRef
 23854  
                     {
 23855  19
                     REFERENCE668=(Token)match(input,REFERENCE,FOLLOW_REFERENCE_in_rdfLiteral6648); 
 23856  19
                     REFERENCE668_tree = 
 23857  189
                     (Object)adaptor.create(REFERENCE668)
 23858  
                     ;
 23859  19
                     adaptor.addChild(root_0, REFERENCE668_tree);
 23860  189
 
 23861  189
 
 23862  19
                     pushFollow(FOLLOW_iriRef_in_rdfLiteral6650);
 23863  19
                     iriRef669=iriRef();
 23864  
 
 23865  19
                     state._fsp--;
 23866  
 
 23867  19
                     adaptor.addChild(root_0, iriRef669.getTree());
 23868  
 
 23869  
                     }
 23870  
 
 23871  
 
 23872  
                     }
 23873  189
                     break;
 23874  189
 
 23875  
             }
 23876  
 
 23877  
 
 23878  
             }
 23879  141
 
 23880  189
             retval.stop = input.LT(-1);
 23881  141
 
 23882  
 
 23883  189
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 23884  189
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 23885  
 
 23886  
         }
 23887  0
         catch (RecognitionException re) {
 23888  141
             reportError(re);
 23889  141
             recover(input,re);
 23890  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 23891  
 
 23892  141
         }
 23893  
 
 23894  141
         finally {
 23895  
                 // do for sure before leaving
 23896  330
         }
 23897  189
         return retval;
 23898  141
     }
 23899  
     // $ANTLR end "rdfLiteral"
 23900  
 
 23901  
 
 23902  141
     public static class numericLiteral_return extends ParserRuleReturnScope {
 23903  
         Object tree;
 23904  141
         public Object getTree() { return tree; }
 23905  141
     };
 23906  
 
 23907  
 
 23908  
     // $ANTLR start "numericLiteral"
 23909  
     // com\\googlecode\\sparkleg\\Sparql.g:630:1: numericLiteral : ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative );
 23910  128
     public final SparqlParser.numericLiteral_return numericLiteral() throws RecognitionException {
 23911  141
         SparqlParser.numericLiteral_return retval = new SparqlParser.numericLiteral_return();
 23912  269
         retval.start = input.LT(1);
 23913  
 
 23914  
 
 23915  141
         Object root_0 = null;
 23916  
 
 23917  146
         SparqlParser.numericLiteralUnsigned_return numericLiteralUnsigned670 =null;
 23918  
 
 23919  146
         SparqlParser.numericLiteralPositive_return numericLiteralPositive671 =null;
 23920  
 
 23921  141
         SparqlParser.numericLiteralNegative_return numericLiteralNegative672 =null;
 23922  
 
 23923  
 
 23924  8
 
 23925  
         try {
 23926  8
             // com\\googlecode\\sparkleg\\Sparql.g:631:5: ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative )
 23927  141
             int alt141=3;
 23928  141
             switch ( input.LA(1) ) {
 23929  
             case DECIMAL:
 23930  
             case DOUBLE:
 23931  
             case INTEGER:
 23932  
                 {
 23933  128
                 alt141=1;
 23934  
                 }
 23935  269
                 break;
 23936  
             case DECIMAL_POSITIVE:
 23937  
             case DOUBLE_POSITIVE:
 23938  
             case INTEGER_POSITIVE:
 23939  128
                 {
 23940  5
                 alt141=2;
 23941  
                 }
 23942  133
                 break;
 23943  128
             case DECIMAL_NEGATIVE:
 23944  
             case DOUBLE_NEGATIVE:
 23945  128
             case INTEGER_NEGATIVE:
 23946  
                 {
 23947  136
                 alt141=3;
 23948  
                 }
 23949  8
                 break;
 23950  128
             default:
 23951  0
                 NoViableAltException nvae =
 23952  
                     new NoViableAltException("", 141, 0, input);
 23953  
 
 23954  5
                 throw nvae;
 23955  
 
 23956  
             }
 23957  5
 
 23958  146
             switch (alt141) {
 23959  
                 case 1 :
 23960  5
                     // com\\googlecode\\sparkleg\\Sparql.g:631:7: numericLiteralUnsigned
 23961  
                     {
 23962  133
                     root_0 = (Object)adaptor.nil();
 23963  
 
 23964  
 
 23965  133
                     pushFollow(FOLLOW_numericLiteralUnsigned_in_numericLiteral6670);
 23966  128
                     numericLiteralUnsigned670=numericLiteralUnsigned();
 23967  
 
 23968  128
                     state._fsp--;
 23969  8
 
 23970  128
                     adaptor.addChild(root_0, numericLiteralUnsigned670.getTree());
 23971  
 
 23972  8
                     }
 23973  136
                     break;
 23974  
                 case 2 :
 23975  8
                     // com\\googlecode\\sparkleg\\Sparql.g:632:7: numericLiteralPositive
 23976  
                     {
 23977  13
                     root_0 = (Object)adaptor.nil();
 23978  
 
 23979  
 
 23980  5
                     pushFollow(FOLLOW_numericLiteralPositive_in_numericLiteral6678);
 23981  5
                     numericLiteralPositive671=numericLiteralPositive();
 23982  
 
 23983  146
                     state._fsp--;
 23984  
 
 23985  5
                     adaptor.addChild(root_0, numericLiteralPositive671.getTree());
 23986  141
 
 23987  141
                     }
 23988  5
                     break;
 23989  
                 case 3 :
 23990  
                     // com\\googlecode\\sparkleg\\Sparql.g:633:7: numericLiteralNegative
 23991  
                     {
 23992  8
                     root_0 = (Object)adaptor.nil();
 23993  
 
 23994  
 
 23995  8
                     pushFollow(FOLLOW_numericLiteralNegative_in_numericLiteral6686);
 23996  8
                     numericLiteralNegative672=numericLiteralNegative();
 23997  
 
 23998  8
                     state._fsp--;
 23999  141
 
 24000  149
                     adaptor.addChild(root_0, numericLiteralNegative672.getTree());
 24001  
 
 24002  
                     }
 24003  
                     break;
 24004  
 
 24005  128
             }
 24006  141
             retval.stop = input.LT(-1);
 24007  128
 
 24008  
 
 24009  141
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24010  141
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24011  
 
 24012  
         }
 24013  0
         catch (RecognitionException re) {
 24014  128
             reportError(re);
 24015  128
             recover(input,re);
 24016  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24017  
 
 24018  128
         }
 24019  
 
 24020  128
         finally {
 24021  
                 // do for sure before leaving
 24022  269
         }
 24023  141
         return retval;
 24024  
     }
 24025  
     // $ANTLR end "numericLiteral"
 24026  
 
 24027  
 
 24028  128
     public static class numericLiteralUnsigned_return extends ParserRuleReturnScope {
 24029  
         Object tree;
 24030  128
         public Object getTree() { return tree; }
 24031  128
     };
 24032  
 
 24033  128
 
 24034  128
     // $ANTLR start "numericLiteralUnsigned"
 24035  128
     // com\\googlecode\\sparkleg\\Sparql.g:636:1: numericLiteralUnsigned : ( INTEGER | DECIMAL | DOUBLE );
 24036  
     public final SparqlParser.numericLiteralUnsigned_return numericLiteralUnsigned() throws RecognitionException {
 24037  128
         SparqlParser.numericLiteralUnsigned_return retval = new SparqlParser.numericLiteralUnsigned_return();
 24038  256
         retval.start = input.LT(1);
 24039  
 
 24040  
 
 24041  128
         Object root_0 = null;
 24042  
 
 24043  128
         Token set673=null;
 24044  
 
 24045  128
         Object set673_tree=null;
 24046  
 
 24047  
         try {
 24048  128
             // com\\googlecode\\sparkleg\\Sparql.g:637:5: ( INTEGER | DECIMAL | DOUBLE )
 24049  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24050  
             {
 24051  256
             root_0 = (Object)adaptor.nil();
 24052  128
 
 24053  
 
 24054  128
             set673=(Token)input.LT(1);
 24055  
 
 24056  128
             if ( input.LA(1)==DECIMAL||input.LA(1)==DOUBLE||input.LA(1)==INTEGER ) {
 24057  128
                 input.consume();
 24058  128
                 adaptor.addChild(root_0, 
 24059  
                 (Object)adaptor.create(set673)
 24060  
                 );
 24061  128
                 state.errorRecovery=false;
 24062  
             }
 24063  
             else {
 24064  128
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24065  128
                 throw mse;
 24066  
             }
 24067  
 
 24068  
 
 24069  
             }
 24070  25
 
 24071  128
             retval.stop = input.LT(-1);
 24072  25
 
 24073  
 
 24074  128
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24075  128
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24076  
 
 24077  
         }
 24078  0
         catch (RecognitionException re) {
 24079  25
             reportError(re);
 24080  25
             recover(input,re);
 24081  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24082  
 
 24083  25
         }
 24084  
 
 24085  25
         finally {
 24086  
                 // do for sure before leaving
 24087  153
         }
 24088  128
         return retval;
 24089  
     }
 24090  
     // $ANTLR end "numericLiteralUnsigned"
 24091  
 
 24092  
 
 24093  25
     public static class numericLiteralPositive_return extends ParserRuleReturnScope {
 24094  
         Object tree;
 24095  25
         public Object getTree() { return tree; }
 24096  25
     };
 24097  
 
 24098  25
 
 24099  25
     // $ANTLR start "numericLiteralPositive"
 24100  25
     // com\\googlecode\\sparkleg\\Sparql.g:642:1: numericLiteralPositive : ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE );
 24101  
     public final SparqlParser.numericLiteralPositive_return numericLiteralPositive() throws RecognitionException {
 24102  25
         SparqlParser.numericLiteralPositive_return retval = new SparqlParser.numericLiteralPositive_return();
 24103  50
         retval.start = input.LT(1);
 24104  
 
 24105  
 
 24106  25
         Object root_0 = null;
 24107  
 
 24108  25
         Token set674=null;
 24109  
 
 24110  25
         Object set674_tree=null;
 24111  
 
 24112  
         try {
 24113  25
             // com\\googlecode\\sparkleg\\Sparql.g:643:5: ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE )
 24114  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24115  
             {
 24116  50
             root_0 = (Object)adaptor.nil();
 24117  25
 
 24118  
 
 24119  25
             set674=(Token)input.LT(1);
 24120  
 
 24121  25
             if ( input.LA(1)==DECIMAL_POSITIVE||input.LA(1)==DOUBLE_POSITIVE||input.LA(1)==INTEGER_POSITIVE ) {
 24122  25
                 input.consume();
 24123  25
                 adaptor.addChild(root_0, 
 24124  
                 (Object)adaptor.create(set674)
 24125  
                 );
 24126  25
                 state.errorRecovery=false;
 24127  
             }
 24128  
             else {
 24129  25
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24130  25
                 throw mse;
 24131  
             }
 24132  
 
 24133  
 
 24134  
             }
 24135  8
 
 24136  25
             retval.stop = input.LT(-1);
 24137  8
 
 24138  
 
 24139  25
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24140  25
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24141  
 
 24142  
         }
 24143  0
         catch (RecognitionException re) {
 24144  8
             reportError(re);
 24145  8
             recover(input,re);
 24146  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24147  
 
 24148  8
         }
 24149  
 
 24150  8
         finally {
 24151  
                 // do for sure before leaving
 24152  33
         }
 24153  25
         return retval;
 24154  
     }
 24155  
     // $ANTLR end "numericLiteralPositive"
 24156  
 
 24157  
 
 24158  8
     public static class numericLiteralNegative_return extends ParserRuleReturnScope {
 24159  
         Object tree;
 24160  8
         public Object getTree() { return tree; }
 24161  8
     };
 24162  
 
 24163  8
 
 24164  8
     // $ANTLR start "numericLiteralNegative"
 24165  8
     // com\\googlecode\\sparkleg\\Sparql.g:648:1: numericLiteralNegative : ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE );
 24166  
     public final SparqlParser.numericLiteralNegative_return numericLiteralNegative() throws RecognitionException {
 24167  8
         SparqlParser.numericLiteralNegative_return retval = new SparqlParser.numericLiteralNegative_return();
 24168  16
         retval.start = input.LT(1);
 24169  
 
 24170  
 
 24171  8
         Object root_0 = null;
 24172  
 
 24173  8
         Token set675=null;
 24174  
 
 24175  8
         Object set675_tree=null;
 24176  
 
 24177  
         try {
 24178  8
             // com\\googlecode\\sparkleg\\Sparql.g:649:5: ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE )
 24179  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24180  
             {
 24181  16
             root_0 = (Object)adaptor.nil();
 24182  8
 
 24183  
 
 24184  8
             set675=(Token)input.LT(1);
 24185  
 
 24186  8
             if ( input.LA(1)==DECIMAL_NEGATIVE||input.LA(1)==DOUBLE_NEGATIVE||input.LA(1)==INTEGER_NEGATIVE ) {
 24187  8
                 input.consume();
 24188  8
                 adaptor.addChild(root_0, 
 24189  
                 (Object)adaptor.create(set675)
 24190  
                 );
 24191  8
                 state.errorRecovery=false;
 24192  
             }
 24193  
             else {
 24194  8
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24195  8
                 throw mse;
 24196  
             }
 24197  
 
 24198  
 
 24199  
             }
 24200  8
 
 24201  8
             retval.stop = input.LT(-1);
 24202  8
 
 24203  
 
 24204  8
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24205  8
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24206  
 
 24207  
         }
 24208  0
         catch (RecognitionException re) {
 24209  8
             reportError(re);
 24210  8
             recover(input,re);
 24211  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24212  
 
 24213  8
         }
 24214  
 
 24215  8
         finally {
 24216  
                 // do for sure before leaving
 24217  16
         }
 24218  8
         return retval;
 24219  
     }
 24220  
     // $ANTLR end "numericLiteralNegative"
 24221  
 
 24222  
 
 24223  8
     public static class booleanLiteral_return extends ParserRuleReturnScope {
 24224  
         Object tree;
 24225  8
         public Object getTree() { return tree; }
 24226  8
     };
 24227  
 
 24228  8
 
 24229  8
     // $ANTLR start "booleanLiteral"
 24230  8
     // com\\googlecode\\sparkleg\\Sparql.g:654:1: booleanLiteral : ( TRUE | FALSE );
 24231  
     public final SparqlParser.booleanLiteral_return booleanLiteral() throws RecognitionException {
 24232  8
         SparqlParser.booleanLiteral_return retval = new SparqlParser.booleanLiteral_return();
 24233  16
         retval.start = input.LT(1);
 24234  
 
 24235  
 
 24236  8
         Object root_0 = null;
 24237  
 
 24238  8
         Token set676=null;
 24239  
 
 24240  8
         Object set676_tree=null;
 24241  
 
 24242  
         try {
 24243  8
             // com\\googlecode\\sparkleg\\Sparql.g:655:5: ( TRUE | FALSE )
 24244  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24245  
             {
 24246  16
             root_0 = (Object)adaptor.nil();
 24247  8
 
 24248  
 
 24249  8
             set676=(Token)input.LT(1);
 24250  
 
 24251  8
             if ( input.LA(1)==FALSE||input.LA(1)==TRUE ) {
 24252  8
                 input.consume();
 24253  8
                 adaptor.addChild(root_0, 
 24254  
                 (Object)adaptor.create(set676)
 24255  
                 );
 24256  8
                 state.errorRecovery=false;
 24257  
             }
 24258  
             else {
 24259  8
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24260  8
                 throw mse;
 24261  
             }
 24262  
 
 24263  
 
 24264  
             }
 24265  190
 
 24266  8
             retval.stop = input.LT(-1);
 24267  190
 
 24268  
 
 24269  8
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24270  8
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24271  
 
 24272  
         }
 24273  0
         catch (RecognitionException re) {
 24274  190
             reportError(re);
 24275  190
             recover(input,re);
 24276  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24277  
 
 24278  190
         }
 24279  
 
 24280  190
         finally {
 24281  
                 // do for sure before leaving
 24282  198
         }
 24283  8
         return retval;
 24284  
     }
 24285  
     // $ANTLR end "booleanLiteral"
 24286  
 
 24287  
 
 24288  190
     public static class string_return extends ParserRuleReturnScope {
 24289  
         Object tree;
 24290  190
         public Object getTree() { return tree; }
 24291  190
     };
 24292  
 
 24293  190
 
 24294  190
     // $ANTLR start "string"
 24295  190
     // com\\googlecode\\sparkleg\\Sparql.g:659:1: string : ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 );
 24296  
     public final SparqlParser.string_return string() throws RecognitionException {
 24297  190
         SparqlParser.string_return retval = new SparqlParser.string_return();
 24298  380
         retval.start = input.LT(1);
 24299  
 
 24300  
 
 24301  190
         Object root_0 = null;
 24302  
 
 24303  190
         Token set677=null;
 24304  
 
 24305  190
         Object set677_tree=null;
 24306  
 
 24307  
         try {
 24308  190
             // com\\googlecode\\sparkleg\\Sparql.g:660:5: ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 )
 24309  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24310  
             {
 24311  380
             root_0 = (Object)adaptor.nil();
 24312  190
 
 24313  
 
 24314  190
             set677=(Token)input.LT(1);
 24315  
 
 24316  190
             if ( (input.LA(1) >= STRING_LITERAL1 && input.LA(1) <= STRING_LITERAL_LONG2) ) {
 24317  190
                 input.consume();
 24318  190
                 adaptor.addChild(root_0, 
 24319  
                 (Object)adaptor.create(set677)
 24320  
                 );
 24321  190
                 state.errorRecovery=false;
 24322  
             }
 24323  
             else {
 24324  190
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24325  190
                 throw mse;
 24326  
             }
 24327  
 
 24328  
 
 24329  
             }
 24330  2177
 
 24331  190
             retval.stop = input.LT(-1);
 24332  2177
 
 24333  
 
 24334  190
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24335  190
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24336  
 
 24337  
         }
 24338  0
         catch (RecognitionException re) {
 24339  2177
             reportError(re);
 24340  2177
             recover(input,re);
 24341  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24342  
 
 24343  2177
         }
 24344  
 
 24345  2177
         finally {
 24346  2177
                 // do for sure before leaving
 24347  190
         }
 24348  190
         return retval;
 24349  2177
     }
 24350  
     // $ANTLR end "string"
 24351  
 
 24352  
 
 24353  2177
     public static class iriRef_return extends ParserRuleReturnScope {
 24354  2177
         Object tree;
 24355  2177
         public Object getTree() { return tree; }
 24356  
     };
 24357  237
 
 24358  
 
 24359  237
     // $ANTLR start "iriRef"
 24360  
     // com\\googlecode\\sparkleg\\Sparql.g:666:1: iriRef : ( IRI_REF | prefixedName );
 24361  
     public final SparqlParser.iriRef_return iriRef() throws RecognitionException {
 24362  2177
         SparqlParser.iriRef_return retval = new SparqlParser.iriRef_return();
 24363  4117
         retval.start = input.LT(1);
 24364  
 
 24365  1940
 
 24366  2177
         Object root_0 = null;
 24367  
 
 24368  2177
         Token IRI_REF678=null;
 24369  2177
         SparqlParser.prefixedName_return prefixedName679 =null;
 24370  
 
 24371  
 
 24372  2177
         Object IRI_REF678_tree=null;
 24373  
 
 24374  2177
         try {
 24375  
             // com\\googlecode\\sparkleg\\Sparql.g:667:5: ( IRI_REF | prefixedName )
 24376  2177
             int alt142=2;
 24377  2177
             switch ( input.LA(1) ) {
 24378  237
             case IRI_REF:
 24379  
                 {
 24380  237
                 alt142=1;
 24381  237
                 }
 24382  474
                 break;
 24383  
             case PNAME_LN:
 24384  
             case PNAME_NS:
 24385  237
                 {
 24386  1940
                 alt142=2;
 24387  
                 }
 24388  1940
                 break;
 24389  237
             default:
 24390  0
                 NoViableAltException nvae =
 24391  
                     new NoViableAltException("", 142, 0, input);
 24392  
 
 24393  1940
                 throw nvae;
 24394  
 
 24395  
             }
 24396  1940
 
 24397  4117
             switch (alt142) {
 24398  
                 case 1 :
 24399  1940
                     // com\\googlecode\\sparkleg\\Sparql.g:667:7: IRI_REF
 24400  
                     {
 24401  2177
                     root_0 = (Object)adaptor.nil();
 24402  
 
 24403  
 
 24404  237
                     IRI_REF678=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_iriRef6869); 
 24405  237
                     IRI_REF678_tree = 
 24406  
                     (Object)adaptor.create(IRI_REF678)
 24407  2177
                     ;
 24408  237
                     adaptor.addChild(root_0, IRI_REF678_tree);
 24409  
 
 24410  2177
 
 24411  2177
                     }
 24412  237
                     break;
 24413  
                 case 2 :
 24414  
                     // com\\googlecode\\sparkleg\\Sparql.g:668:7: prefixedName
 24415  
                     {
 24416  1940
                     root_0 = (Object)adaptor.nil();
 24417  
 
 24418  
 
 24419  1940
                     pushFollow(FOLLOW_prefixedName_in_iriRef6877);
 24420  1940
                     prefixedName679=prefixedName();
 24421  
 
 24422  1940
                     state._fsp--;
 24423  2177
 
 24424  4117
                     adaptor.addChild(root_0, prefixedName679.getTree());
 24425  
 
 24426  
                     }
 24427  
                     break;
 24428  
 
 24429  1940
             }
 24430  2177
             retval.stop = input.LT(-1);
 24431  1940
 
 24432  
 
 24433  2177
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24434  2177
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24435  
 
 24436  
         }
 24437  0
         catch (RecognitionException re) {
 24438  1940
             reportError(re);
 24439  1940
             recover(input,re);
 24440  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24441  
 
 24442  1940
         }
 24443  
 
 24444  1940
         finally {
 24445  
                 // do for sure before leaving
 24446  4117
         }
 24447  2177
         return retval;
 24448  
     }
 24449  
     // $ANTLR end "iriRef"
 24450  
 
 24451  
 
 24452  1940
     public static class prefixedName_return extends ParserRuleReturnScope {
 24453  
         Object tree;
 24454  1940
         public Object getTree() { return tree; }
 24455  1940
     };
 24456  
 
 24457  1940
 
 24458  1940
     // $ANTLR start "prefixedName"
 24459  1940
     // com\\googlecode\\sparkleg\\Sparql.g:671:1: prefixedName : ( PNAME_LN | PNAME_NS );
 24460  
     public final SparqlParser.prefixedName_return prefixedName() throws RecognitionException {
 24461  1940
         SparqlParser.prefixedName_return retval = new SparqlParser.prefixedName_return();
 24462  3880
         retval.start = input.LT(1);
 24463  
 
 24464  
 
 24465  1940
         Object root_0 = null;
 24466  
 
 24467  1940
         Token set680=null;
 24468  
 
 24469  1940
         Object set680_tree=null;
 24470  
 
 24471  
         try {
 24472  1940
             // com\\googlecode\\sparkleg\\Sparql.g:672:5: ( PNAME_LN | PNAME_NS )
 24473  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24474  
             {
 24475  3880
             root_0 = (Object)adaptor.nil();
 24476  1940
 
 24477  
 
 24478  1940
             set680=(Token)input.LT(1);
 24479  
 
 24480  1940
             if ( (input.LA(1) >= PNAME_LN && input.LA(1) <= PNAME_NS) ) {
 24481  1940
                 input.consume();
 24482  1940
                 adaptor.addChild(root_0, 
 24483  
                 (Object)adaptor.create(set680)
 24484  
                 );
 24485  1940
                 state.errorRecovery=false;
 24486  
             }
 24487  
             else {
 24488  1940
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24489  1940
                 throw mse;
 24490  
             }
 24491  
 
 24492  
 
 24493  
             }
 24494  102
 
 24495  1940
             retval.stop = input.LT(-1);
 24496  102
 
 24497  
 
 24498  1940
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24499  1940
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24500  
 
 24501  
         }
 24502  0
         catch (RecognitionException re) {
 24503  102
             reportError(re);
 24504  102
             recover(input,re);
 24505  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24506  
 
 24507  102
         }
 24508  
 
 24509  102
         finally {
 24510  102
                 // do for sure before leaving
 24511  1940
         }
 24512  1940
         return retval;
 24513  102
     }
 24514  
     // $ANTLR end "prefixedName"
 24515  
 
 24516  
 
 24517  102
     public static class blankNode_return extends ParserRuleReturnScope {
 24518  102
         Object tree;
 24519  102
         public Object getTree() { return tree; }
 24520  
     };
 24521  58
 
 24522  
 
 24523  58
     // $ANTLR start "blankNode"
 24524  
     // com\\googlecode\\sparkleg\\Sparql.g:676:1: blankNode : ( BLANK_NODE_LABEL | anon );
 24525  
     public final SparqlParser.blankNode_return blankNode() throws RecognitionException {
 24526  146
         SparqlParser.blankNode_return retval = new SparqlParser.blankNode_return();
 24527  102
         retval.start = input.LT(1);
 24528  44
 
 24529  
 
 24530  102
         Object root_0 = null;
 24531  
 
 24532  102
         Token BLANK_NODE_LABEL681=null;
 24533  102
         SparqlParser.anon_return anon682 =null;
 24534  
 
 24535  
 
 24536  102
         Object BLANK_NODE_LABEL681_tree=null;
 24537  102
 
 24538  
         try {
 24539  
             // com\\googlecode\\sparkleg\\Sparql.g:677:5: ( BLANK_NODE_LABEL | anon )
 24540  102
             int alt143=2;
 24541  160
             switch ( input.LA(1) ) {
 24542  
             case BLANK_NODE_LABEL:
 24543  
                 {
 24544  116
                 alt143=1;
 24545  58
                 }
 24546  58
                 break;
 24547  
             case OPEN_SQUARE_BRACKET:
 24548  58
                 {
 24549  44
                 alt143=2;
 24550  
                 }
 24551  44
                 break;
 24552  58
             default:
 24553  0
                 NoViableAltException nvae =
 24554  
                     new NoViableAltException("", 143, 0, input);
 24555  
 
 24556  44
                 throw nvae;
 24557  
 
 24558  
             }
 24559  44
 
 24560  146
             switch (alt143) {
 24561  
                 case 1 :
 24562  44
                     // com\\googlecode\\sparkleg\\Sparql.g:677:7: BLANK_NODE_LABEL
 24563  
                     {
 24564  102
                     root_0 = (Object)adaptor.nil();
 24565  
 
 24566  
 
 24567  58
                     BLANK_NODE_LABEL681=(Token)match(input,BLANK_NODE_LABEL,FOLLOW_BLANK_NODE_LABEL_in_blankNode6919); 
 24568  58
                     BLANK_NODE_LABEL681_tree = 
 24569  
                     (Object)adaptor.create(BLANK_NODE_LABEL681)
 24570  102
                     ;
 24571  58
                     adaptor.addChild(root_0, BLANK_NODE_LABEL681_tree);
 24572  
 
 24573  102
 
 24574  102
                     }
 24575  58
                     break;
 24576  
                 case 2 :
 24577  
                     // com\\googlecode\\sparkleg\\Sparql.g:678:7: anon
 24578  
                     {
 24579  44
                     root_0 = (Object)adaptor.nil();
 24580  
 
 24581  
 
 24582  44
                     pushFollow(FOLLOW_anon_in_blankNode6927);
 24583  44
                     anon682=anon();
 24584  
 
 24585  44
                     state._fsp--;
 24586  102
 
 24587  146
                     adaptor.addChild(root_0, anon682.getTree());
 24588  
 
 24589  
                     }
 24590  
                     break;
 24591  
 
 24592  44
             }
 24593  102
             retval.stop = input.LT(-1);
 24594  44
 
 24595  
 
 24596  102
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24597  102
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24598  
 
 24599  
         }
 24600  0
         catch (RecognitionException re) {
 24601  44
             reportError(re);
 24602  44
             recover(input,re);
 24603  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24604  
 
 24605  44
         }
 24606  
 
 24607  44
         finally {
 24608  44
                 // do for sure before leaving
 24609  102
         }
 24610  146
         return retval;
 24611  44
     }
 24612  
     // $ANTLR end "blankNode"
 24613  
 
 24614  
 
 24615  44
     public static class anon_return extends ParserRuleReturnScope {
 24616  
         Object tree;
 24617  44
         public Object getTree() { return tree; }
 24618  
     };
 24619  
 
 24620  44
 
 24621  44
     // $ANTLR start "anon"
 24622  
     // com\\googlecode\\sparkleg\\Sparql.g:681:1: anon : OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET ;
 24623  
     public final SparqlParser.anon_return anon() throws RecognitionException {
 24624  88
         SparqlParser.anon_return retval = new SparqlParser.anon_return();
 24625  44
         retval.start = input.LT(1);
 24626  
 
 24627  44
 
 24628  88
         Object root_0 = null;
 24629  
 
 24630  44
         Token OPEN_SQUARE_BRACKET683=null;
 24631  88
         Token CLOSE_SQUARE_BRACKET684=null;
 24632  
 
 24633  44
         Object OPEN_SQUARE_BRACKET683_tree=null;
 24634  44
         Object CLOSE_SQUARE_BRACKET684_tree=null;
 24635  
 
 24636  44
         try {
 24637  
             // com\\googlecode\\sparkleg\\Sparql.g:682:5: ( OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET )
 24638  
             // com\\googlecode\\sparkleg\\Sparql.g:682:7: OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET
 24639  44
             {
 24640  88
             root_0 = (Object)adaptor.nil();
 24641  
 
 24642  
 
 24643  44
             OPEN_SQUARE_BRACKET683=(Token)match(input,OPEN_SQUARE_BRACKET,FOLLOW_OPEN_SQUARE_BRACKET_in_anon6944); 
 24644  44
             OPEN_SQUARE_BRACKET683_tree = 
 24645  
             (Object)adaptor.create(OPEN_SQUARE_BRACKET683)
 24646  
             ;
 24647  44
             adaptor.addChild(root_0, OPEN_SQUARE_BRACKET683_tree);
 24648  
 
 24649  
 
 24650  44
             CLOSE_SQUARE_BRACKET684=(Token)match(input,CLOSE_SQUARE_BRACKET,FOLLOW_CLOSE_SQUARE_BRACKET_in_anon6946); 
 24651  44
             CLOSE_SQUARE_BRACKET684_tree = 
 24652  44
             (Object)adaptor.create(CLOSE_SQUARE_BRACKET684)
 24653  44
             ;
 24654  44
             adaptor.addChild(root_0, CLOSE_SQUARE_BRACKET684_tree);
 24655  
 
 24656  
 
 24657  
             }
 24658  
 
 24659  44
             retval.stop = input.LT(-1);
 24660  979
 
 24661  
 
 24662  44
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24663  44
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24664  
 
 24665  
         }
 24666  0
         catch (RecognitionException re) {
 24667  0
             reportError(re);
 24668  0
             recover(input,re);
 24669  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24670  
 
 24671  
         }
 24672  
 
 24673  1
         finally {
 24674  
                 // do for sure before leaving
 24675  44
         }
 24676  44
         return retval;
 24677  
     }
 24678  
     // $ANTLR end "anon"
 24679  
 
 24680  
     // Delegated rules
 24681  
 
 24682  
 
 24683  979
     protected DFA4 dfa4 = new DFA4(this);
 24684  
     static final String DFA4_eotS =
 24685  
         "\10\uffff";
 24686  
     static final String DFA4_eofS =
 24687  
         "\10\uffff";
 24688  
     static final String DFA4_minS =
 24689  
         "\1\6\1\133\1\u008a\2\uffff\1\6\1\133\1\6";
 24690  
     static final String DFA4_maxS =
 24691  
         "\1\u00cf\1\133\1\u008a\2\uffff\1\u00cf\1\133\1\u00cf";
 24692  
     static final String DFA4_acceptS =
 24693  1
         "\3\uffff\1\1\1\2\3\uffff";
 24694  1
     static final String DFA4_specialS =
 24695  1
         "\10\uffff}>";
 24696  2
     static final String[] DFA4_transitionS = {
 24697  1
             "\1\4\6\uffff\1\3\2\uffff\1\1\12\uffff\1\4\10\uffff\1\3\2\uffff"+
 24698  1
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\30\uffff"+
 24699  
             "\1\4\24\uffff\1\4\10\uffff\1\4\36\uffff\1\2\14\uffff\1\3\60"+
 24700  
             "\uffff\1\4",
 24701  
             "\1\5",
 24702  1
             "\1\6",
 24703  1
             "",
 24704  9
             "",
 24705  8
             "\1\4\6\uffff\1\3\2\uffff\1\1\12\uffff\1\4\10\uffff\1\3\2\uffff"+
 24706  
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\30\uffff"+
 24707  
             "\1\4\24\uffff\1\4\10\uffff\1\4\36\uffff\1\2\14\uffff\1\3\60"+
 24708  
             "\uffff\1\4",
 24709  
             "\1\7",
 24710  
             "\1\4\6\uffff\1\3\2\uffff\1\1\12\uffff\1\4\10\uffff\1\3\2\uffff"+
 24711  979
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\30\uffff"+
 24712  979
             "\1\4\24\uffff\1\4\10\uffff\1\4\36\uffff\1\2\14\uffff\1\3\60"+
 24713  979
             "\uffff\1\4"
 24714  979
     };
 24715  979
 
 24716  1
     static final short[] DFA4_eot = DFA.unpackEncodedString(DFA4_eotS);
 24717  1
     static final short[] DFA4_eof = DFA.unpackEncodedString(DFA4_eofS);
 24718  1
     static final char[] DFA4_min = DFA.unpackEncodedStringToUnsignedChars(DFA4_minS);
 24719  1
     static final char[] DFA4_max = DFA.unpackEncodedStringToUnsignedChars(DFA4_maxS);
 24720  1
     static final short[] DFA4_accept = DFA.unpackEncodedString(DFA4_acceptS);
 24721  1
     static final short[] DFA4_special = DFA.unpackEncodedString(DFA4_specialS);
 24722  
     static final short[][] DFA4_transition;
 24723  
 
 24724  
     static {
 24725  1
         int numStates = DFA4_transitionS.length;
 24726  1
         DFA4_transition = new short[numStates][];
 24727  9
         for (int i=0; i<numStates; i++) {
 24728  9
             DFA4_transition[i] = DFA.unpackEncodedString(DFA4_transitionS[i]);
 24729  1
         }
 24730  1
     }
 24731  1
 
 24732  1
     class DFA4 extends DFA {
 24733  1
 
 24734  1
         public DFA4(BaseRecognizer recognizer) {
 24735  1
             this.recognizer = recognizer;
 24736  1
             this.decisionNumber = 4;
 24737  1
             this.eot = DFA4_eot;
 24738  1
             this.eof = DFA4_eof;
 24739  1
             this.min = DFA4_min;
 24740  1
             this.max = DFA4_max;
 24741  1
             this.accept = DFA4_accept;
 24742  1
             this.special = DFA4_special;
 24743  1
             this.transition = DFA4_transition;
 24744  1
         }
 24745  1
         public String getDescription() {
 24746  1
             return "76:1: query : ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( SEMICOLON ( update )? )* EOF -> ^( UPDATE ( update )+ ) );";
 24747  1
         }
 24748  1
     }
 24749  1
  
 24750  1
 
 24751  2
     public static final BitSet FOLLOW_prologue_in_query155 = new BitSet(new long[]{0x0008001000002000L,0x0000000000000000L,0x0000000040000000L});
 24752  2
     public static final BitSet FOLLOW_selectQuery_in_query158 = new BitSet(new long[]{0x0000000000040000L});
 24753  2
     public static final BitSet FOLLOW_constructQuery_in_query162 = new BitSet(new long[]{0x0000000000040000L});
 24754  2
     public static final BitSet FOLLOW_describeQuery_in_query166 = new BitSet(new long[]{0x0000000000040000L});
 24755  2
     public static final BitSet FOLLOW_askQuery_in_query170 = new BitSet(new long[]{0x0000000000040000L});
 24756  2
     public static final BitSet FOLLOW_bindingsClause_in_query173 = new BitSet(new long[]{0x0000000000000000L});
 24757  2
     public static final BitSet FOLLOW_EOF_in_query175 = new BitSet(new long[]{0x0000000000000002L});
 24758  2
     public static final BitSet FOLLOW_update_in_query206 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000100000000L});
 24759  2
     public static final BitSet FOLLOW_SEMICOLON_in_query209 = new BitSet(new long[]{0x0802028008010040L,0x0004020000100000L,0x0000000100020000L,0x0000000000008000L});
 24760  2
     public static final BitSet FOLLOW_update_in_query211 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000100000000L});
 24761  2
     public static final BitSet FOLLOW_EOF_in_query216 = new BitSet(new long[]{0x0000000000000002L});
 24762  2
     public static final BitSet FOLLOW_baseDecl_in_prologue249 = new BitSet(new long[]{0x0000000000010002L,0x0000000000000000L,0x0000000000020000L});
 24763  2
     public static final BitSet FOLLOW_prefixDecl_in_prologue253 = new BitSet(new long[]{0x0000000000010002L,0x0000000000000000L,0x0000000000020000L});
 24764  2
     public static final BitSet FOLLOW_BASE_in_baseDecl284 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
 24765  2
     public static final BitSet FOLLOW_IRI_REF_in_baseDecl286 = new BitSet(new long[]{0x0000000000000002L});
 24766  2
     public static final BitSet FOLLOW_PREFIX_in_prefixDecl312 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000400L});
 24767  2
     public static final BitSet FOLLOW_PNAME_NS_in_prefixDecl314 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
 24768  2
     public static final BitSet FOLLOW_IRI_REF_in_prefixDecl316 = new BitSet(new long[]{0x0000000000000002L});
 24769  2
     public static final BitSet FOLLOW_selectClause_in_selectQuery343 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24770  2
     public static final BitSet FOLLOW_datasetClause_in_selectQuery345 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24771  2
     public static final BitSet FOLLOW_whereClause_in_selectQuery348 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24772  2
     public static final BitSet FOLLOW_solutionModifier_in_selectQuery350 = new BitSet(new long[]{0x0000000000000002L});
 24773  2
     public static final BitSet FOLLOW_selectClause_in_subSelect384 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L,0x0000000000000000L,0x0000000000002000L});
 24774  2
     public static final BitSet FOLLOW_whereClause_in_subSelect386 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24775  2
     public static final BitSet FOLLOW_solutionModifier_in_subSelect388 = new BitSet(new long[]{0x0000000000000002L});
 24776  2
     public static final BitSet FOLLOW_SELECT_in_selectClause424 = new BitSet(new long[]{0x0020000000004000L,0x0000000000000000L,0x0000000000400000L});
 24777  2
     public static final BitSet FOLLOW_DISTINCT_in_selectClause427 = new BitSet(new long[]{0x0000000000004000L});
 24778  2
     public static final BitSet FOLLOW_REDUCED_in_selectClause431 = new BitSet(new long[]{0x0000000000004000L});
 24779  2
     public static final BitSet FOLLOW_ASTERISK_in_selectClause435 = new BitSet(new long[]{0x0000000000000002L});
 24780  2
     public static final BitSet FOLLOW_SELECT_in_selectClause457 = new BitSet(new long[]{0x0020000000000000L,0x0800000000000000L,0x0000000000400000L,0x0000000000000C00L});
 24781  2
     public static final BitSet FOLLOW_DISTINCT_in_selectClause460 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24782  2
     public static final BitSet FOLLOW_REDUCED_in_selectClause464 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24783  2
     public static final BitSet FOLLOW_selectVariables_in_selectClause471 = new BitSet(new long[]{0x0000000000000002L,0x0800000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24784  2
     public static final BitSet FOLLOW_var_in_selectVariables506 = new BitSet(new long[]{0x0000000000000002L});
 24785  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_selectVariables523 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 24786  2
     public static final BitSet FOLLOW_expression_in_selectVariables525 = new BitSet(new long[]{0x0000000000000800L});
 24787  2
     public static final BitSet FOLLOW_AS_in_selectVariables527 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24788  2
     public static final BitSet FOLLOW_var_in_selectVariables529 = new BitSet(new long[]{0x0000000010000000L});
 24789  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_selectVariables531 = new BitSet(new long[]{0x0000000000000002L});
 24790  2
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery558 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24791  2
     public static final BitSet FOLLOW_constructTemplate_in_constructQuery560 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24792  2
     public static final BitSet FOLLOW_datasetClause_in_constructQuery562 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24793  2
     public static final BitSet FOLLOW_whereClause_in_constructQuery565 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24794  2
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery567 = new BitSet(new long[]{0x0000000000000002L});
 24795  2
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery592 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24796  2
     public static final BitSet FOLLOW_datasetClause_in_constructQuery594 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24797  2
     public static final BitSet FOLLOW_WHERE_in_constructQuery597 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24798  2
     public static final BitSet FOLLOW_groupGraphPattern_in_constructQuery599 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24799  2
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery601 = new BitSet(new long[]{0x0000000000000002L});
 24800  2
     public static final BitSet FOLLOW_DESCRIBE_in_describeQuery637 = new BitSet(new long[]{0x0000000000004000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 24801  2
     public static final BitSet FOLLOW_varOrIRIref_in_describeQuery643 = new BitSet(new long[]{0x0000000000000000L,0x1400010008010840L,0x0000000000000601L,0x0000000000002C00L});
 24802  2
     public static final BitSet FOLLOW_ASTERISK_in_describeQuery649 = new BitSet(new long[]{0x0000000000000000L,0x1400010000010840L,0x0000000000000001L,0x0000000000002000L});
 24803  2
     public static final BitSet FOLLOW_datasetClause_in_describeQuery652 = new BitSet(new long[]{0x0000000000000000L,0x1400010000010840L,0x0000000000000001L,0x0000000000002000L});
 24804  2
     public static final BitSet FOLLOW_whereClause_in_describeQuery655 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24805  2
     public static final BitSet FOLLOW_solutionModifier_in_describeQuery658 = new BitSet(new long[]{0x0000000000000002L});
 24806  2
     public static final BitSet FOLLOW_ASK_in_askQuery697 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24807  2
     public static final BitSet FOLLOW_datasetClause_in_askQuery699 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24808  2
     public static final BitSet FOLLOW_whereClause_in_askQuery702 = new BitSet(new long[]{0x0000000000000002L});
 24809  2
     public static final BitSet FOLLOW_FROM_in_datasetClause730 = new BitSet(new long[]{0x0000000000000000L,0x0008000008000000L,0x0000000000000600L});
 24810  2
     public static final BitSet FOLLOW_NAMED_in_datasetClause732 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24811  2
     public static final BitSet FOLLOW_iriRef_in_datasetClause735 = new BitSet(new long[]{0x0000000000000002L});
 24812  2
     public static final BitSet FOLLOW_WHERE_in_whereClause763 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24813  2
     public static final BitSet FOLLOW_groupGraphPattern_in_whereClause766 = new BitSet(new long[]{0x0000000000000002L});
 24814  2
     public static final BitSet FOLLOW_groupClause_in_solutionModifier791 = new BitSet(new long[]{0x0000000000000002L,0x0400010000010000L,0x0000000000000001L});
 24815  2
     public static final BitSet FOLLOW_havingClause_in_solutionModifier794 = new BitSet(new long[]{0x0000000000000002L,0x0400010000000000L,0x0000000000000001L});
 24816  2
     public static final BitSet FOLLOW_orderClause_in_solutionModifier797 = new BitSet(new long[]{0x0000000000000002L,0x0400010000000000L});
 24817  2
     public static final BitSet FOLLOW_limitOffsetClauses_in_solutionModifier800 = new BitSet(new long[]{0x0000000000000002L});
 24818  2
     public static final BitSet FOLLOW_GROUP_in_groupClause832 = new BitSet(new long[]{0x0000000002000000L});
 24819  2
     public static final BitSet FOLLOW_BY_in_groupClause834 = new BitSet(new long[]{0x2000184884C00020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24820  2
     public static final BitSet FOLLOW_groupCondition_in_groupClause836 = new BitSet(new long[]{0x2000184884C00022L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24821  2
     public static final BitSet FOLLOW_builtInCall_in_groupCondition870 = new BitSet(new long[]{0x0000000000000002L});
 24822  2
     public static final BitSet FOLLOW_functionCall_in_groupCondition886 = new BitSet(new long[]{0x0000000000000002L});
 24823  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_groupCondition902 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 24824  2
     public static final BitSet FOLLOW_expression_in_groupCondition904 = new BitSet(new long[]{0x0000000010000800L});
 24825  2
     public static final BitSet FOLLOW_AS_in_groupCondition907 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24826  2
     public static final BitSet FOLLOW_var_in_groupCondition909 = new BitSet(new long[]{0x0000000010000000L});
 24827  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_groupCondition913 = new BitSet(new long[]{0x0000000000000002L});
 24828  2
     public static final BitSet FOLLOW_var_in_groupCondition937 = new BitSet(new long[]{0x0000000000000002L});
 24829  2
     public static final BitSet FOLLOW_HAVING_in_havingClause966 = new BitSet(new long[]{0x2000184884C00020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020086L});
 24830  2
     public static final BitSet FOLLOW_constraint_in_havingClause968 = new BitSet(new long[]{0x2000184884C00022L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020086L});
 24831  2
     public static final BitSet FOLLOW_ORDER_in_orderClause1000 = new BitSet(new long[]{0x0000000002000000L});
 24832  2
     public static final BitSet FOLLOW_BY_in_orderClause1002 = new BitSet(new long[]{0x2004184884C01020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24833  2
     public static final BitSet FOLLOW_orderCondition_in_orderClause1004 = new BitSet(new long[]{0x2004184884C01022L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24834  2
     public static final BitSet FOLLOW_ASC_in_orderCondition1031 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 24835  2
     public static final BitSet FOLLOW_brackettedExpression_in_orderCondition1033 = new BitSet(new long[]{0x0000000000000002L});
 24836  2
     public static final BitSet FOLLOW_DESC_in_orderCondition1051 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 24837  2
     public static final BitSet FOLLOW_brackettedExpression_in_orderCondition1053 = new BitSet(new long[]{0x0000000000000002L});
 24838  2
     public static final BitSet FOLLOW_constraint_in_orderCondition1071 = new BitSet(new long[]{0x0000000000000002L});
 24839  2
     public static final BitSet FOLLOW_var_in_orderCondition1087 = new BitSet(new long[]{0x0000000000000002L});
 24840  2
     public static final BitSet FOLLOW_limitClause_in_limitOffsetClauses1117 = new BitSet(new long[]{0x0000000000000002L,0x0400000000000000L});
 24841  2
     public static final BitSet FOLLOW_offsetClause_in_limitOffsetClauses1119 = new BitSet(new long[]{0x0000000000000002L});
 24842  2
     public static final BitSet FOLLOW_offsetClause_in_limitOffsetClauses1135 = new BitSet(new long[]{0x0000000000000002L,0x0000010000000000L});
 24843  2
     public static final BitSet FOLLOW_limitClause_in_limitOffsetClauses1137 = new BitSet(new long[]{0x0000000000000002L});
 24844  2
     public static final BitSet FOLLOW_LIMIT_in_limitClause1162 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
 24845  2
     public static final BitSet FOLLOW_INTEGER_in_limitClause1164 = new BitSet(new long[]{0x0000000000000002L});
 24846  2
     public static final BitSet FOLLOW_OFFSET_in_offsetClause1189 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
 24847  2
     public static final BitSet FOLLOW_INTEGER_in_offsetClause1191 = new BitSet(new long[]{0x0000000000000002L});
 24848  2
     public static final BitSet FOLLOW_BINDINGS_in_bindingsClause1217 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24849  2
     public static final BitSet FOLLOW_var_in_bindingsClause1219 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24850  2
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_bindingsClause1222 = new BitSet(new long[]{0x0000000020000000L,0x0800000000000000L});
 24851  2
     public static final BitSet FOLLOW_bindingValueList_in_bindingsClause1224 = new BitSet(new long[]{0x0000000020000000L,0x0800000000000000L});
 24852  2
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_bindingsClause1227 = new BitSet(new long[]{0x0000000000000002L});
 24853  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_bindingValueList1263 = new BitSet(new long[]{0x0700E00010000000L,0x0000000008E00008L,0x0007800000000600L,0x0000000000000011L});
 24854  2
     public static final BitSet FOLLOW_bindingValue_in_bindingValueList1265 = new BitSet(new long[]{0x0700E00010000000L,0x0000000008E00008L,0x0007800000000600L,0x0000000000000011L});
 24855  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_bindingValueList1268 = new BitSet(new long[]{0x0000000000000002L});
 24856  2
     public static final BitSet FOLLOW_iriRef_in_bindingValue1299 = new BitSet(new long[]{0x0000000000000002L});
 24857  2
     public static final BitSet FOLLOW_rdfLiteral_in_bindingValue1303 = new BitSet(new long[]{0x0000000000000002L});
 24858  2
     public static final BitSet FOLLOW_numericLiteral_in_bindingValue1307 = new BitSet(new long[]{0x0000000000000002L});
 24859  2
     public static final BitSet FOLLOW_booleanLiteral_in_bindingValue1311 = new BitSet(new long[]{0x0000000000000002L});
 24860  2
     public static final BitSet FOLLOW_UNDEF_in_bindingValue1315 = new BitSet(new long[]{0x0000000000000002L});
 24861  2
     public static final BitSet FOLLOW_prologue_in_update1336 = new BitSet(new long[]{0x0802028008000040L,0x0004020000100000L,0x0000000000000000L,0x0000000000008000L});
 24862  2
     public static final BitSet FOLLOW_load_in_update1339 = new BitSet(new long[]{0x0000000000000002L});
 24863  2
     public static final BitSet FOLLOW_clear_in_update1343 = new BitSet(new long[]{0x0000000000000002L});
 24864  2
     public static final BitSet FOLLOW_drop_in_update1347 = new BitSet(new long[]{0x0000000000000002L});
 24865  2
     public static final BitSet FOLLOW_add_in_update1351 = new BitSet(new long[]{0x0000000000000002L});
 24866  2
     public static final BitSet FOLLOW_move_in_update1355 = new BitSet(new long[]{0x0000000000000002L});
 24867  2
     public static final BitSet FOLLOW_copy_in_update1359 = new BitSet(new long[]{0x0000000000000002L});
 24868  2
     public static final BitSet FOLLOW_create_in_update1363 = new BitSet(new long[]{0x0000000000000002L});
 24869  2
     public static final BitSet FOLLOW_insert_in_update1367 = new BitSet(new long[]{0x0000000000000002L});
 24870  2
     public static final BitSet FOLLOW_delete_in_update1371 = new BitSet(new long[]{0x0000000000000002L});
 24871  2
     public static final BitSet FOLLOW_modify_in_update1375 = new BitSet(new long[]{0x0000000000000002L});
 24872  2
     public static final BitSet FOLLOW_LOAD_in_load1438 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000020000000600L});
 24873  2
     public static final BitSet FOLLOW_SILENT_in_load1440 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24874  2
     public static final BitSet FOLLOW_iriRef_in_load1443 = new BitSet(new long[]{0x0000000000000002L,0x0000000001000000L});
 24875  2
     public static final BitSet FOLLOW_INTO_in_load1446 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
 24876  2
     public static final BitSet FOLLOW_graphRef_in_load1448 = new BitSet(new long[]{0x0000000000000002L});
 24877  2
     public static final BitSet FOLLOW_CLEAR_in_clear1485 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L,0x0000020000000000L});
 24878  2
     public static final BitSet FOLLOW_SILENT_in_clear1488 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L});
 24879  2
     public static final BitSet FOLLOW_graphRefAll_in_clear1491 = new BitSet(new long[]{0x0000000000000002L});
 24880  2
     public static final BitSet FOLLOW_DROP_in_drop1523 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L,0x0000020000000000L});
 24881  2
     public static final BitSet FOLLOW_SILENT_in_drop1525 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L});
 24882  2
     public static final BitSet FOLLOW_graphRefAll_in_drop1528 = new BitSet(new long[]{0x0000000000000002L});
 24883  2
     public static final BitSet FOLLOW_CREATE_in_create1557 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L,0x0000020000000000L});
 24884  2
     public static final BitSet FOLLOW_SILENT_in_create1559 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
 24885  2
     public static final BitSet FOLLOW_graphRef_in_create1562 = new BitSet(new long[]{0x0000000000000002L});
 24886  2
     public static final BitSet FOLLOW_ADD_in_add1594 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 24887  2
     public static final BitSet FOLLOW_SILENT_in_add1596 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 24888  2
     public static final BitSet FOLLOW_graphOrDefault_in_add1601 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
 24889  2
     public static final BitSet FOLLOW_TO_in_add1603 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 24890  2
     public static final BitSet FOLLOW_graphOrDefault_in_add1607 = new BitSet(new long[]{0x0000000000000002L});
 24891  2
     public static final BitSet FOLLOW_MOVE_in_move1643 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 24892  2
     public static final BitSet FOLLOW_SILENT_in_move1645 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 24893  2
     public static final BitSet FOLLOW_graphOrDefault_in_move1650 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
 24894  2
     public static final BitSet FOLLOW_TO_in_move1652 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 24895  2
     public static final BitSet FOLLOW_graphOrDefault_in_move1656 = new BitSet(new long[]{0x0000000000000002L});
 24896  2
     public static final BitSet FOLLOW_COPY_in_copy1692 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 24897  2
     public static final BitSet FOLLOW_SILENT_in_copy1694 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 24898  2
     public static final BitSet FOLLOW_graphOrDefault_in_copy1699 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
 24899  2
     public static final BitSet FOLLOW_TO_in_copy1701 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 24900  2
     public static final BitSet FOLLOW_graphOrDefault_in_copy1705 = new BitSet(new long[]{0x0000000000000002L});
 24901  2
     public static final BitSet FOLLOW_INSERT_in_insert1737 = new BitSet(new long[]{0x0000040000000000L});
 24902  2
     public static final BitSet FOLLOW_DATA_in_insert1739 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24903  2
     public static final BitSet FOLLOW_quadPattern_in_insert1741 = new BitSet(new long[]{0x0000000000000002L});
 24904  2
     public static final BitSet FOLLOW_DELETE_in_delete1775 = new BitSet(new long[]{0x0000040000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002000L});
 24905  2
     public static final BitSet FOLLOW_deleteData_in_delete1778 = new BitSet(new long[]{0x0000000000000002L});
 24906  2
     public static final BitSet FOLLOW_deleteWhere_in_delete1782 = new BitSet(new long[]{0x0000000000000002L});
 24907  2
     public static final BitSet FOLLOW_DATA_in_deleteData1800 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24908  2
     public static final BitSet FOLLOW_quadPattern_in_deleteData1802 = new BitSet(new long[]{0x0000000000000002L});
 24909  2
     public static final BitSet FOLLOW_WHERE_in_deleteWhere1829 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24910  2
     public static final BitSet FOLLOW_quadPattern_in_deleteWhere1831 = new BitSet(new long[]{0x0000000000000002L});
 24911  2
     public static final BitSet FOLLOW_WITH_in_modify1863 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24912  2
     public static final BitSet FOLLOW_iriRef_in_modify1865 = new BitSet(new long[]{0x0002000000000000L,0x0000000000100000L});
 24913  2
     public static final BitSet FOLLOW_deleteClause_in_modify1870 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L,0x0000000000000000L,0x0000000000002100L});
 24914  2
     public static final BitSet FOLLOW_insertClause_in_modify1872 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002100L});
 24915  2
     public static final BitSet FOLLOW_insertClause_in_modify1877 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002100L});
 24916  2
     public static final BitSet FOLLOW_usingClause_in_modify1880 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002100L});
 24917  2
     public static final BitSet FOLLOW_WHERE_in_modify1883 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24918  2
     public static final BitSet FOLLOW_groupGraphPattern_in_modify1885 = new BitSet(new long[]{0x0000000000000002L});
 24919  2
     public static final BitSet FOLLOW_DELETE_in_deleteClause1932 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24920  2
     public static final BitSet FOLLOW_quadPattern_in_deleteClause1934 = new BitSet(new long[]{0x0000000000000002L});
 24921  2
     public static final BitSet FOLLOW_INSERT_in_insertClause1963 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24922  2
     public static final BitSet FOLLOW_quadPattern_in_insertClause1965 = new BitSet(new long[]{0x0000000000000002L});
 24923  2
     public static final BitSet FOLLOW_USING_in_usingClause1988 = new BitSet(new long[]{0x0000000000000000L,0x0008000008000000L,0x0000000000000600L});
 24924  2
     public static final BitSet FOLLOW_NAMED_in_usingClause1990 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24925  2
     public static final BitSet FOLLOW_iriRef_in_usingClause1993 = new BitSet(new long[]{0x0000000000000002L});
 24926  2
     public static final BitSet FOLLOW_DEFAULT_in_graphOrDefault2024 = new BitSet(new long[]{0x0000000000000002L});
 24927  2
     public static final BitSet FOLLOW_GRAPH_in_graphOrDefault2033 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24928  2
     public static final BitSet FOLLOW_iriRef_in_graphOrDefault2036 = new BitSet(new long[]{0x0000000000000002L});
 24929  2
     public static final BitSet FOLLOW_GRAPH_in_graphRef2063 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24930  2
     public static final BitSet FOLLOW_iriRef_in_graphRef2065 = new BitSet(new long[]{0x0000000000000002L});
 24931  2
     public static final BitSet FOLLOW_graphRef_in_graphRefAll2082 = new BitSet(new long[]{0x0000000000000002L});
 24932  2
     public static final BitSet FOLLOW_DEFAULT_in_graphRefAll2086 = new BitSet(new long[]{0x0000000000000002L});
 24933  2
     public static final BitSet FOLLOW_NAMED_in_graphRefAll2090 = new BitSet(new long[]{0x0000000000000002L});
 24934  2
     public static final BitSet FOLLOW_ALL_in_graphRefAll2094 = new BitSet(new long[]{0x0000000000000002L});
 24935  2
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_quadPattern2111 = new BitSet(new long[]{0x0700E00020200000L,0x2800000008E00108L,0x0007800000000600L,0x0000000000000C01L});
 24936  2
     public static final BitSet FOLLOW_quads_in_quadPattern2113 = new BitSet(new long[]{0x0000000020000000L});
 24937  2
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_quadPattern2115 = new BitSet(new long[]{0x0000000000000002L});
 24938  2
     public static final BitSet FOLLOW_triplesTemplate_in_quads2140 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});
 24939  2
     public static final BitSet FOLLOW_quadsNotTriples_in_quads2144 = new BitSet(new long[]{0x0780E00000200002L,0x2800000008E00108L,0x0007800000000600L,0x0000000000000C01L});
 24940  2
     public static final BitSet FOLLOW_DOT_in_quads2146 = new BitSet(new long[]{0x0700E00000200002L,0x2800000008E00108L,0x0007800000000600L,0x0000000000000C01L});
 24941  2
     public static final BitSet FOLLOW_triplesTemplate_in_quads2149 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});
 24942  2
     public static final BitSet FOLLOW_GRAPH_in_quadsNotTriples2188 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 24943  2
     public static final BitSet FOLLOW_varOrIRIref_in_quadsNotTriples2190 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24944  2
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_quadsNotTriples2192 = new BitSet(new long[]{0x0700E00020200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 24945  2
     public static final BitSet FOLLOW_triplesTemplate_in_quadsNotTriples2194 = new BitSet(new long[]{0x0000000020000000L});
 24946  2
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_quadsNotTriples2197 = new BitSet(new long[]{0x0000000000000002L});
 24947  2
     public static final BitSet FOLLOW_triplesSameSubject_in_triplesTemplate2229 = new BitSet(new long[]{0x0080000000000002L});
 24948  2
     public static final BitSet FOLLOW_DOT_in_triplesTemplate2232 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 24949  2
     public static final BitSet FOLLOW_triplesSameSubject_in_triplesTemplate2234 = new BitSet(new long[]{0x0080000000000002L});
 24950  2
     public static final BitSet FOLLOW_DOT_in_triplesTemplate2238 = new BitSet(new long[]{0x0000000000000002L});
 24951  2
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2270 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
 24952  2
     public static final BitSet FOLLOW_subSelect_in_groupGraphPattern2272 = new BitSet(new long[]{0x0000000020000000L});
 24953  2
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2274 = new BitSet(new long[]{0x0000000000000002L});
 24954  2
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2290 = new BitSet(new long[]{0x0700E00000220000L,0x7800400008E00118L,0x0007800400000600L,0x0000000000000C01L});
 24955  2
     public static final BitSet FOLLOW_groupGraphPatternSub_in_groupGraphPattern2292 = new BitSet(new long[]{0x0000000020000000L});
 24956  2
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2294 = new BitSet(new long[]{0x0000000000000002L});
 24957  2
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2310 = new BitSet(new long[]{0x0000000020000000L});
 24958  2
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2312 = new BitSet(new long[]{0x0000000000000002L});
 24959  2
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSub2341 = new BitSet(new long[]{0x0000000000020002L,0x5000400000000110L,0x0000000400000000L});
 24960  2
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2343 = new BitSet(new long[]{0x0000000000020002L,0x5000400000000110L,0x0000000400000000L});
 24961  2
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2359 = new BitSet(new long[]{0x0000000000020002L,0x5000400000000110L,0x0000000400000000L});
 24962  2
     public static final BitSet FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail2382 = new BitSet(new long[]{0x0780E00000200002L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 24963  2
     public static final BitSet FOLLOW_DOT_in_groupGraphPatternSubDetail2384 = new BitSet(new long[]{0x0700E00000200002L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 24964  2
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSubDetail2387 = new BitSet(new long[]{0x0000000000000002L});
 24965  2
     public static final BitSet FOLLOW_triplesSameSubjectPath_in_triplesBlock2412 = new BitSet(new long[]{0x0080000000000002L});
 24966  2
     public static final BitSet FOLLOW_DOT_in_triplesBlock2415 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 24967  2
     public static final BitSet FOLLOW_triplesSameSubjectPath_in_triplesBlock2417 = new BitSet(new long[]{0x0080000000000002L});
 24968  2
     public static final BitSet FOLLOW_DOT_in_triplesBlock2421 = new BitSet(new long[]{0x0000000000000002L});
 24969  2
     public static final BitSet FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples2444 = new BitSet(new long[]{0x0000000000000002L});
 24970  2
     public static final BitSet FOLLOW_optionalGraphPattern_in_graphPatternNotTriples2448 = new BitSet(new long[]{0x0000000000000002L});
 24971  2
     public static final BitSet FOLLOW_minusGraphPattern_in_graphPatternNotTriples2452 = new BitSet(new long[]{0x0000000000000002L});
 24972  2
     public static final BitSet FOLLOW_graphGraphPattern_in_graphPatternNotTriples2456 = new BitSet(new long[]{0x0000000000000002L});
 24973  2
     public static final BitSet FOLLOW_serviceGraphPattern_in_graphPatternNotTriples2460 = new BitSet(new long[]{0x0000000000000002L});
 24974  2
     public static final BitSet FOLLOW_filter_in_graphPatternNotTriples2464 = new BitSet(new long[]{0x0000000000000002L});
 24975  2
     public static final BitSet FOLLOW_bind_in_graphPatternNotTriples2468 = new BitSet(new long[]{0x0000000000000002L});
 24976  2
     public static final BitSet FOLLOW_OPTIONAL_in_optionalGraphPattern2485 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24977  2
     public static final BitSet FOLLOW_groupGraphPattern_in_optionalGraphPattern2487 = new BitSet(new long[]{0x0000000000000002L});
 24978  2
     public static final BitSet FOLLOW_GRAPH_in_graphGraphPattern2512 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 24979  2
     public static final BitSet FOLLOW_varOrIRIref_in_graphGraphPattern2514 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24980  2
     public static final BitSet FOLLOW_groupGraphPattern_in_graphGraphPattern2516 = new BitSet(new long[]{0x0000000000000002L});
 24981  2
     public static final BitSet FOLLOW_SERVICE_in_serviceGraphPattern2543 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000020000000600L,0x0000000000000C00L});
 24982  2
     public static final BitSet FOLLOW_SILENT_in_serviceGraphPattern2545 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 24983  2
     public static final BitSet FOLLOW_varOrIRIref_in_serviceGraphPattern2548 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24984  2
     public static final BitSet FOLLOW_groupGraphPattern_in_serviceGraphPattern2550 = new BitSet(new long[]{0x0000000000000002L});
 24985  2
     public static final BitSet FOLLOW_BIND_in_bind2584 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 24986  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_bind2586 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 24987  2
     public static final BitSet FOLLOW_expression_in_bind2588 = new BitSet(new long[]{0x0000000000000800L});
 24988  2
     public static final BitSet FOLLOW_AS_in_bind2590 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24989  2
     public static final BitSet FOLLOW_var_in_bind2592 = new BitSet(new long[]{0x0000000010000000L});
 24990  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_bind2594 = new BitSet(new long[]{0x0000000000000002L});
 24991  2
     public static final BitSet FOLLOW_MINUS_KEYWORD_in_minusGraphPattern2631 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24992  2
     public static final BitSet FOLLOW_groupGraphPattern_in_minusGraphPattern2633 = new BitSet(new long[]{0x0000000000000002L});
 24993  2
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2661 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
 24994  2
     public static final BitSet FOLLOW_UNION_in_groupOrUnionGraphPattern2669 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24995  2
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2673 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
 24996  2
     public static final BitSet FOLLOW_FILTER_in_filter2705 = new BitSet(new long[]{0x2000184884C00020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020086L});
 24997  2
     public static final BitSet FOLLOW_constraint_in_filter2707 = new BitSet(new long[]{0x0000000000000002L});
 24998  2
     public static final BitSet FOLLOW_brackettedExpression_in_constraint2732 = new BitSet(new long[]{0x0000000000000002L});
 24999  2
     public static final BitSet FOLLOW_builtInCall_in_constraint2740 = new BitSet(new long[]{0x0000000000000002L});
 25000  2
     public static final BitSet FOLLOW_functionCall_in_constraint2748 = new BitSet(new long[]{0x0000000000000002L});
 25001  2
     public static final BitSet FOLLOW_iriRef_in_functionCall2765 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25002  2
     public static final BitSet FOLLOW_argList_in_functionCall2767 = new BitSet(new long[]{0x0000000000000002L});
 25003  2
     public static final BitSet FOLLOW_nil_in_argList2798 = new BitSet(new long[]{0x0000000000000002L});
 25004  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_argList2810 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25005  2
     public static final BitSet FOLLOW_DISTINCT_in_argList2812 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25006  2
     public static final BitSet FOLLOW_expression_in_argList2815 = new BitSet(new long[]{0x0000000210000000L});
 25007  2
     public static final BitSet FOLLOW_COMMA_in_argList2818 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25008  2
     public static final BitSet FOLLOW_expression_in_argList2820 = new BitSet(new long[]{0x0000000210000000L});
 25009  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_argList2824 = new BitSet(new long[]{0x0000000000000002L});
 25010  2
     public static final BitSet FOLLOW_nil_in_expressionList2850 = new BitSet(new long[]{0x0000000000000002L});
 25011  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_expressionList2854 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25012  2
     public static final BitSet FOLLOW_expression_in_expressionList2856 = new BitSet(new long[]{0x0000000210000000L});
 25013  2
     public static final BitSet FOLLOW_COMMA_in_expressionList2859 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25014  2
     public static final BitSet FOLLOW_expression_in_expressionList2861 = new BitSet(new long[]{0x0000000210000000L});
 25015  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_expressionList2865 = new BitSet(new long[]{0x0000000000000002L});
 25016  2
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_constructTemplate2896 = new BitSet(new long[]{0x0700E00020200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25017  2
     public static final BitSet FOLLOW_constructTriples_in_constructTemplate2898 = new BitSet(new long[]{0x0000000020000000L});
 25018  2
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_constructTemplate2901 = new BitSet(new long[]{0x0000000000000002L});
 25019  2
     public static final BitSet FOLLOW_triplesSameSubject_in_constructTriples2927 = new BitSet(new long[]{0x0080000000000002L});
 25020  2
     public static final BitSet FOLLOW_DOT_in_constructTriples2930 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25021  2
     public static final BitSet FOLLOW_triplesSameSubject_in_constructTriples2932 = new BitSet(new long[]{0x0080000000000002L});
 25022  2
     public static final BitSet FOLLOW_DOT_in_constructTriples2936 = new BitSet(new long[]{0x0000000000000002L});
 25023  2
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubject2959 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25024  2
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject2961 = new BitSet(new long[]{0x0000000000000002L});
 25025  2
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubject2985 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25026  2
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject2987 = new BitSet(new long[]{0x0000000000000002L});
 25027  2
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3017 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25028  2
     public static final BitSet FOLLOW_SEMICOLON_in_propertyListNotEmpty3020 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000100000600L,0x0000000000000C00L});
 25029  2
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3022 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25030  2
     public static final BitSet FOLLOW_graphNode_in_objectList3048 = new BitSet(new long[]{0x0000000200000002L});
 25031  2
     public static final BitSet FOLLOW_COMMA_in_objectList3051 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25032  2
     public static final BitSet FOLLOW_graphNode_in_objectList3053 = new BitSet(new long[]{0x0000000200000002L});
 25033  2
     public static final BitSet FOLLOW_varOrIRIref_in_verb3081 = new BitSet(new long[]{0x0000000000000002L});
 25034  2
     public static final BitSet FOLLOW_A_in_verb3089 = new BitSet(new long[]{0x0000000000000002L});
 25035  2
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubjectPath3106 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25036  2
     public static final BitSet FOLLOW_propertyListNotEmptyPath_in_triplesSameSubjectPath3108 = new BitSet(new long[]{0x0000000000000002L});
 25037  2
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubjectPath3130 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25038  2
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath3132 = new BitSet(new long[]{0x0000000000000002L});
 25039  2
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3164 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25040  2
     public static final BitSet FOLLOW_SEMICOLON_in_propertyListNotEmptyPath3167 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000100000600L,0x0000000000000C00L});
 25041  2
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3169 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25042  2
     public static final BitSet FOLLOW_verbSimpleOrPath_in_propertyListNotEmptyDetails3196 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25043  2
     public static final BitSet FOLLOW_objectList_in_propertyListNotEmptyDetails3198 = new BitSet(new long[]{0x0000000000000002L});
 25044  2
     public static final BitSet FOLLOW_verbPath_in_verbSimpleOrPath3228 = new BitSet(new long[]{0x0000000000000002L});
 25045  2
     public static final BitSet FOLLOW_verbSimple_in_verbSimpleOrPath3236 = new BitSet(new long[]{0x0000000000000002L});
 25046  2
     public static final BitSet FOLLOW_path_in_verbPath3255 = new BitSet(new long[]{0x0000000000000002L});
 25047  2
     public static final BitSet FOLLOW_var_in_verbSimple3276 = new BitSet(new long[]{0x0000000000000002L});
 25048  2
     public static final BitSet FOLLOW_pathSequence_in_path3298 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000080L});
 25049  2
     public static final BitSet FOLLOW_PIPE_in_path3301 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L});
 25050  2
     public static final BitSet FOLLOW_pathSequence_in_path3303 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000080L});
 25051  2
     public static final BitSet FOLLOW_pathEltOrInverse_in_pathSequence3332 = new BitSet(new long[]{0x0040000000000002L});
 25052  2
     public static final BitSet FOLLOW_DIVIDE_in_pathSequence3335 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L});
 25053  2
     public static final BitSet FOLLOW_pathEltOrInverse_in_pathSequence3337 = new BitSet(new long[]{0x0040000000000002L});
 25054  2
     public static final BitSet FOLLOW_INVERSE_in_pathEltOrInverse3365 = new BitSet(new long[]{0x0000000000000010L,0x0810000008000000L,0x0000000000000600L});
 25055  2
     public static final BitSet FOLLOW_pathElt_in_pathEltOrInverse3368 = new BitSet(new long[]{0x0000000000000002L});
 25056  2
     public static final BitSet FOLLOW_pathPrimary_in_pathElt3396 = new BitSet(new long[]{0x0000000000004002L,0x1000000000000000L,0x0000000000100100L});
 25057  2
     public static final BitSet FOLLOW_pathMod_in_pathElt3398 = new BitSet(new long[]{0x0000000000000002L});
 25058  2
     public static final BitSet FOLLOW_ASTERISK_in_pathMod3417 = new BitSet(new long[]{0x0000000000000002L});
 25059  2
     public static final BitSet FOLLOW_QUESTION_MARK_in_pathMod3421 = new BitSet(new long[]{0x0000000000000002L});
 25060  2
     public static final BitSet FOLLOW_PLUS_in_pathMod3425 = new BitSet(new long[]{0x0000000000000002L});
 25061  2
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_pathMod3429 = new BitSet(new long[]{0x0000000200000000L,0x0000000000200000L});
 25062  2
     public static final BitSet FOLLOW_INTEGER_in_pathMod3432 = new BitSet(new long[]{0x0000000220000000L});
 25063  2
     public static final BitSet FOLLOW_COMMA_in_pathMod3435 = new BitSet(new long[]{0x0000000020000000L,0x0000000000200000L});
 25064  2
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3438 = new BitSet(new long[]{0x0000000000000002L});
 25065  2
     public static final BitSet FOLLOW_INTEGER_in_pathMod3442 = new BitSet(new long[]{0x0000000020000000L});
 25066  2
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3444 = new BitSet(new long[]{0x0000000000000002L});
 25067  2
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3449 = new BitSet(new long[]{0x0000000000000002L});
 25068  2
     public static final BitSet FOLLOW_COMMA_in_pathMod3454 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
 25069  2
     public static final BitSet FOLLOW_INTEGER_in_pathMod3456 = new BitSet(new long[]{0x0000000020000000L});
 25070  2
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3458 = new BitSet(new long[]{0x0000000000000002L});
 25071  2
     public static final BitSet FOLLOW_iriRef_in_pathPrimary3477 = new BitSet(new long[]{0x0000000000000002L});
 25072  2
     public static final BitSet FOLLOW_A_in_pathPrimary3493 = new BitSet(new long[]{0x0000000000000002L});
 25073  2
     public static final BitSet FOLLOW_NEGATION_in_pathPrimary3509 = new BitSet(new long[]{0x0000000000000010L,0x080000000A000000L,0x0000000000000600L});
 25074  2
     public static final BitSet FOLLOW_pathNegatedPropertySet_in_pathPrimary3511 = new BitSet(new long[]{0x0000000000000002L});
 25075  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_pathPrimary3529 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L});
 25076  2
     public static final BitSet FOLLOW_path_in_pathPrimary3531 = new BitSet(new long[]{0x0000000010000000L});
 25077  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_pathPrimary3533 = new BitSet(new long[]{0x0000000000000002L});
 25078  2
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3558 = new BitSet(new long[]{0x0000000000000002L});
 25079  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_pathNegatedPropertySet3574 = new BitSet(new long[]{0x0000000010000010L,0x000000000A000000L,0x0000000000000600L});
 25080  2
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3577 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000000000080L});
 25081  2
     public static final BitSet FOLLOW_PIPE_in_pathNegatedPropertySet3580 = new BitSet(new long[]{0x0000000000000010L,0x000000000A000000L,0x0000000000000600L});
 25082  2
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3582 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000000000080L});
 25083  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_pathNegatedPropertySet3588 = new BitSet(new long[]{0x0000000000000002L});
 25084  2
     public static final BitSet FOLLOW_INVERSE_in_pathOneInPropertySet3617 = new BitSet(new long[]{0x0000000000000010L,0x0000000008000000L,0x0000000000000600L});
 25085  2
     public static final BitSet FOLLOW_iriRef_in_pathOneInPropertySet3621 = new BitSet(new long[]{0x0000000000000002L});
 25086  2
     public static final BitSet FOLLOW_A_in_pathOneInPropertySet3625 = new BitSet(new long[]{0x0000000000000002L});
 25087  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_triplesNode3644 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25088  2
     public static final BitSet FOLLOW_graphNode_in_triplesNode3646 = new BitSet(new long[]{0x0700E00010200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25089  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_triplesNode3649 = new BitSet(new long[]{0x0000000000000002L});
 25090  2
     public static final BitSet FOLLOW_OPEN_SQUARE_BRACKET_in_triplesNode3666 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25091  2
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesNode3668 = new BitSet(new long[]{0x0000000040000000L});
 25092  2
     public static final BitSet FOLLOW_CLOSE_SQUARE_BRACKET_in_triplesNode3670 = new BitSet(new long[]{0x0000000000000002L});
 25093  2
     public static final BitSet FOLLOW_varOrTerm_in_graphNode3695 = new BitSet(new long[]{0x0000000000000002L});
 25094  2
     public static final BitSet FOLLOW_triplesNode_in_graphNode3699 = new BitSet(new long[]{0x0000000000000002L});
 25095  2
     public static final BitSet FOLLOW_var_in_varOrTerm3716 = new BitSet(new long[]{0x0000000000000002L});
 25096  2
     public static final BitSet FOLLOW_graphTerm_in_varOrTerm3724 = new BitSet(new long[]{0x0000000000000002L});
 25097  2
     public static final BitSet FOLLOW_var_in_varOrIRIref3741 = new BitSet(new long[]{0x0000000000000002L});
 25098  2
     public static final BitSet FOLLOW_iriRef_in_varOrIRIref3745 = new BitSet(new long[]{0x0000000000000002L});
 25099  2
     public static final BitSet FOLLOW_iriRef_in_graphTerm3783 = new BitSet(new long[]{0x0000000000000002L});
 25100  2
     public static final BitSet FOLLOW_rdfLiteral_in_graphTerm3791 = new BitSet(new long[]{0x0000000000000002L});
 25101  2
     public static final BitSet FOLLOW_numericLiteral_in_graphTerm3799 = new BitSet(new long[]{0x0000000000000002L});
 25102  2
     public static final BitSet FOLLOW_booleanLiteral_in_graphTerm3807 = new BitSet(new long[]{0x0000000000000002L});
 25103  2
     public static final BitSet FOLLOW_blankNode_in_graphTerm3815 = new BitSet(new long[]{0x0000000000000002L});
 25104  2
     public static final BitSet FOLLOW_nil_in_graphTerm3823 = new BitSet(new long[]{0x0000000000000002L});
 25105  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_nil3844 = new BitSet(new long[]{0x0000000010000000L});
 25106  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_nil3846 = new BitSet(new long[]{0x0000000000000002L});
 25107  2
     public static final BitSet FOLLOW_conditionalOrExpression_in_expression3863 = new BitSet(new long[]{0x0000000000000002L});
 25108  2
     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression3883 = new BitSet(new long[]{0x0000000000000002L,0x8000000000000000L});
 25109  2
     public static final BitSet FOLLOW_OR_in_conditionalOrExpression3892 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25110  2
     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression3896 = new BitSet(new long[]{0x0000000000000002L,0x8000000000000000L});
 25111  2
     public static final BitSet FOLLOW_valueLogical_in_conditionalAndExpression3930 = new BitSet(new long[]{0x0000000000000102L});
 25112  2
     public static final BitSet FOLLOW_AND_in_conditionalAndExpression3939 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25113  2
     public static final BitSet FOLLOW_valueLogical_in_conditionalAndExpression3943 = new BitSet(new long[]{0x0000000000000102L});
 25114  2
     public static final BitSet FOLLOW_relationalExpression_in_valueLogical3974 = new BitSet(new long[]{0x0000000000000002L});
 25115  2
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression3994 = new BitSet(new long[]{0x8000000000000002L,0x006000C000080600L});
 25116  2
     public static final BitSet FOLLOW_EQUAL_in_relationalExpression4004 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25117  2
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4008 = new BitSet(new long[]{0x0000000000000002L});
 25118  2
     public static final BitSet FOLLOW_NOT_EQUAL_in_relationalExpression4065 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25119  2
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4069 = new BitSet(new long[]{0x0000000000000002L});
 25120  2
     public static final BitSet FOLLOW_LESS_in_relationalExpression4124 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25121  2
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4128 = new BitSet(new long[]{0x0000000000000002L});
 25122  2
     public static final BitSet FOLLOW_GREATER_in_relationalExpression4183 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25123  2
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4187 = new BitSet(new long[]{0x0000000000000002L});
 25124  2
     public static final BitSet FOLLOW_LESS_EQUAL_in_relationalExpression4241 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25125  2
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4245 = new BitSet(new long[]{0x0000000000000002L});
 25126  2
     public static final BitSet FOLLOW_GREATER_EQUAL_in_relationalExpression4299 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25127  2
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4303 = new BitSet(new long[]{0x0000000000000002L});
 25128  2
     public static final BitSet FOLLOW_IN_in_relationalExpression4359 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25129  2
     public static final BitSet FOLLOW_expressionList_in_relationalExpression4363 = new BitSet(new long[]{0x0000000000000002L});
 25130  2
     public static final BitSet FOLLOW_NOT_in_relationalExpression4417 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25131  2
     public static final BitSet FOLLOW_IN_in_relationalExpression4419 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25132  2
     public static final BitSet FOLLOW_expressionList_in_relationalExpression4423 = new BitSet(new long[]{0x0000000000000002L});
 25133  2
     public static final BitSet FOLLOW_additiveExpression_in_numericExpression4457 = new BitSet(new long[]{0x0000000000000002L});
 25134  2
     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4477 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25135  2
     public static final BitSet FOLLOW_additiveOperator_in_additiveExpression4487 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25136  2
     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4491 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25137  2
     public static final BitSet FOLLOW_numericLiteralPositive_in_additiveExpression4558 = new BitSet(new long[]{0x0640C00000004002L,0x0000200000C00000L,0x0000000000000100L});
 25138  2
     public static final BitSet FOLLOW_numericLiteralNegative_in_additiveExpression4576 = new BitSet(new long[]{0x0640C00000004002L,0x0000200000C00000L,0x0000000000000100L});
 25139  2
     public static final BitSet FOLLOW_ASTERISK_in_additiveExpression4640 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25140  2
     public static final BitSet FOLLOW_unaryExpression_in_additiveExpression4644 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25141  2
     public static final BitSet FOLLOW_DIVIDE_in_additiveExpression4710 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25142  2
     public static final BitSet FOLLOW_unaryExpression_in_additiveExpression4714 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25143  2
     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression4780 = new BitSet(new long[]{0x0040000000004002L});
 25144  2
     public static final BitSet FOLLOW_multiplicativeOperator_in_multiplicativeExpression4789 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25145  2
     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression4793 = new BitSet(new long[]{0x0040000000004002L});
 25146  2
     public static final BitSet FOLLOW_NEGATION_in_unaryExpression4849 = new BitSet(new long[]{0x2700F94884C08020L,0x09229C2FECE62029L,0x073FFCF83F200600L,0x0000000000020C87L});
 25147  2
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4851 = new BitSet(new long[]{0x0000000000000002L});
 25148  2
     public static final BitSet FOLLOW_PLUS_in_unaryExpression4869 = new BitSet(new long[]{0x2700F94884C08020L,0x09229C2FECE62029L,0x073FFCF83F200600L,0x0000000000020C87L});
 25149  2
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4871 = new BitSet(new long[]{0x0000000000000002L});
 25150  2
     public static final BitSet FOLLOW_MINUS_in_unaryExpression4889 = new BitSet(new long[]{0x2700F94884C08020L,0x09229C2FECE62029L,0x073FFCF83F200600L,0x0000000000020C87L});
 25151  2
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4891 = new BitSet(new long[]{0x0000000000000002L});
 25152  2
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4909 = new BitSet(new long[]{0x0000000000000002L});
 25153  2
     public static final BitSet FOLLOW_brackettedExpression_in_primaryExpression4934 = new BitSet(new long[]{0x0000000000000002L});
 25154  2
     public static final BitSet FOLLOW_builtInCall_in_primaryExpression4938 = new BitSet(new long[]{0x0000000000000002L});
 25155  2
     public static final BitSet FOLLOW_iriRefOrFunction_in_primaryExpression4942 = new BitSet(new long[]{0x0000000000000002L});
 25156  2
     public static final BitSet FOLLOW_rdfLiteral_in_primaryExpression4946 = new BitSet(new long[]{0x0000000000000002L});
 25157  2
     public static final BitSet FOLLOW_numericLiteral_in_primaryExpression4950 = new BitSet(new long[]{0x0000000000000002L});
 25158  2
     public static final BitSet FOLLOW_booleanLiteral_in_primaryExpression4954 = new BitSet(new long[]{0x0000000000000002L});
 25159  2
     public static final BitSet FOLLOW_var_in_primaryExpression4958 = new BitSet(new long[]{0x0000000000000002L});
 25160  2
     public static final BitSet FOLLOW_aggregate_in_primaryExpression4962 = new BitSet(new long[]{0x0000000000000002L});
 25161  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_brackettedExpression4979 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25162  2
     public static final BitSet FOLLOW_expression_in_brackettedExpression4981 = new BitSet(new long[]{0x0000000010000000L});
 25163  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_brackettedExpression4983 = new BitSet(new long[]{0x0000000000000002L});
 25164  2
     public static final BitSet FOLLOW_STR_in_builtInCall5008 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25165  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5010 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25166  2
     public static final BitSet FOLLOW_expression_in_builtInCall5012 = new BitSet(new long[]{0x0000000010000000L});
 25167  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5014 = new BitSet(new long[]{0x0000000000000002L});
 25168  2
     public static final BitSet FOLLOW_LANG_in_builtInCall5030 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25169  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5032 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25170  2
     public static final BitSet FOLLOW_expression_in_builtInCall5034 = new BitSet(new long[]{0x0000000010000000L});
 25171  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5036 = new BitSet(new long[]{0x0000000000000002L});
 25172  2
     public static final BitSet FOLLOW_LANGMATCHES_in_builtInCall5052 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25173  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5054 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25174  2
     public static final BitSet FOLLOW_expression_in_builtInCall5056 = new BitSet(new long[]{0x0000000200000000L});
 25175  2
     public static final BitSet FOLLOW_COMMA_in_builtInCall5058 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25176  2
     public static final BitSet FOLLOW_expression_in_builtInCall5060 = new BitSet(new long[]{0x0000000010000000L});
 25177  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5062 = new BitSet(new long[]{0x0000000000000002L});
 25178  2
     public static final BitSet FOLLOW_DATATYPE_in_builtInCall5079 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25179  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5081 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25180  2
     public static final BitSet FOLLOW_expression_in_builtInCall5083 = new BitSet(new long[]{0x0000000010000000L});
 25181  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5085 = new BitSet(new long[]{0x0000000000000002L});
 25182  2
     public static final BitSet FOLLOW_BOUND_in_builtInCall5101 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25183  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5103 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 25184  2
     public static final BitSet FOLLOW_var_in_builtInCall5105 = new BitSet(new long[]{0x0000000010000000L});
 25185  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5107 = new BitSet(new long[]{0x0000000000000002L});
 25186  2
     public static final BitSet FOLLOW_IRI_in_builtInCall5123 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25187  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5125 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25188  2
     public static final BitSet FOLLOW_expression_in_builtInCall5127 = new BitSet(new long[]{0x0000000010000000L});
 25189  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5129 = new BitSet(new long[]{0x0000000000000002L});
 25190  2
     public static final BitSet FOLLOW_URI_in_builtInCall5145 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25191  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5147 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25192  2
     public static final BitSet FOLLOW_expression_in_builtInCall5149 = new BitSet(new long[]{0x0000000010000000L});
 25193  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5151 = new BitSet(new long[]{0x0000000000000002L});
 25194  2
     public static final BitSet FOLLOW_BNODE_in_builtInCall5167 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25195  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5170 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25196  2
     public static final BitSet FOLLOW_expression_in_builtInCall5172 = new BitSet(new long[]{0x0000000010000000L});
 25197  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5174 = new BitSet(new long[]{0x0000000000000002L});
 25198  2
     public static final BitSet FOLLOW_BNODE_in_builtInCall5191 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25199  2
     public static final BitSet FOLLOW_nil_in_builtInCall5193 = new BitSet(new long[]{0x0000000000000002L});
 25200  2
     public static final BitSet FOLLOW_RAND_in_builtInCall5205 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25201  2
     public static final BitSet FOLLOW_nil_in_builtInCall5207 = new BitSet(new long[]{0x0000000000000002L});
 25202  2
     public static final BitSet FOLLOW_ABS_in_builtInCall5219 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25203  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5221 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25204  2
     public static final BitSet FOLLOW_expression_in_builtInCall5223 = new BitSet(new long[]{0x0000000010000000L});
 25205  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5225 = new BitSet(new long[]{0x0000000000000002L});
 25206  2
     public static final BitSet FOLLOW_CEIL_in_builtInCall5241 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25207  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5243 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25208  2
     public static final BitSet FOLLOW_expression_in_builtInCall5245 = new BitSet(new long[]{0x0000000010000000L});
 25209  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5247 = new BitSet(new long[]{0x0000000000000002L});
 25210  2
     public static final BitSet FOLLOW_FLOOR_in_builtInCall5263 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25211  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5265 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25212  2
     public static final BitSet FOLLOW_expression_in_builtInCall5267 = new BitSet(new long[]{0x0000000010000000L});
 25213  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5269 = new BitSet(new long[]{0x0000000000000002L});
 25214  2
     public static final BitSet FOLLOW_ROUND_in_builtInCall5285 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25215  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5287 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25216  2
     public static final BitSet FOLLOW_expression_in_builtInCall5289 = new BitSet(new long[]{0x0000000010000000L});
 25217  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5291 = new BitSet(new long[]{0x0000000000000002L});
 25218  2
     public static final BitSet FOLLOW_CONCAT_in_builtInCall5307 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25219  2
     public static final BitSet FOLLOW_expressionList_in_builtInCall5309 = new BitSet(new long[]{0x0000000000000002L});
 25220  2
     public static final BitSet FOLLOW_subStringExpression_in_builtInCall5325 = new BitSet(new long[]{0x0000000000000002L});
 25221  2
     public static final BitSet FOLLOW_STRLEN_in_builtInCall5337 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25222  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5339 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25223  2
     public static final BitSet FOLLOW_expression_in_builtInCall5341 = new BitSet(new long[]{0x0000000010000000L});
 25224  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5343 = new BitSet(new long[]{0x0000000000000002L});
 25225  2
     public static final BitSet FOLLOW_UCASE_in_builtInCall5359 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25226  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5361 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25227  2
     public static final BitSet FOLLOW_expression_in_builtInCall5363 = new BitSet(new long[]{0x0000000010000000L});
 25228  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5365 = new BitSet(new long[]{0x0000000000000002L});
 25229  2
     public static final BitSet FOLLOW_LCASE_in_builtInCall5381 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25230  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5383 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25231  2
     public static final BitSet FOLLOW_expression_in_builtInCall5385 = new BitSet(new long[]{0x0000000010000000L});
 25232  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5387 = new BitSet(new long[]{0x0000000000000002L});
 25233  2
     public static final BitSet FOLLOW_ENCODE_FOR_URI_in_builtInCall5403 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25234  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5405 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25235  2
     public static final BitSet FOLLOW_expression_in_builtInCall5407 = new BitSet(new long[]{0x0000000010000000L});
 25236  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5409 = new BitSet(new long[]{0x0000000000000002L});
 25237  2
     public static final BitSet FOLLOW_CONTAINS_in_builtInCall5425 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25238  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5427 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25239  2
     public static final BitSet FOLLOW_expression_in_builtInCall5429 = new BitSet(new long[]{0x0000000200000000L});
 25240  2
     public static final BitSet FOLLOW_COMMA_in_builtInCall5431 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25241  2
     public static final BitSet FOLLOW_expression_in_builtInCall5433 = new BitSet(new long[]{0x0000000010000000L});
 25242  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5435 = new BitSet(new long[]{0x0000000000000002L});
 25243  2
     public static final BitSet FOLLOW_STRSTARTS_in_builtInCall5453 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25244  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5455 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25245  2
     public static final BitSet FOLLOW_expression_in_builtInCall5457 = new BitSet(new long[]{0x0000000200000000L});
 25246  2
     public static final BitSet FOLLOW_COMMA_in_builtInCall5459 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25247  2
     public static final BitSet FOLLOW_expression_in_builtInCall5461 = new BitSet(new long[]{0x0000000010000000L});
 25248  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5463 = new BitSet(new long[]{0x0000000000000002L});
 25249  2
     public static final BitSet FOLLOW_STRENDS_in_builtInCall5481 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25250  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5483 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25251  2
     public static final BitSet FOLLOW_expression_in_builtInCall5485 = new BitSet(new long[]{0x0000000200000000L});
 25252  2
     public static final BitSet FOLLOW_COMMA_in_builtInCall5487 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25253  2
     public static final BitSet FOLLOW_expression_in_builtInCall5489 = new BitSet(new long[]{0x0000000010000000L});
 25254  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5491 = new BitSet(new long[]{0x0000000000000002L});
 25255  2
     public static final BitSet FOLLOW_STRBEFORE_in_builtInCall5509 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25256  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5511 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25257  2
     public static final BitSet FOLLOW_expression_in_builtInCall5513 = new BitSet(new long[]{0x0000000200000000L});
 25258  2
     public static final BitSet FOLLOW_COMMA_in_builtInCall5515 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25259  2
     public static final BitSet FOLLOW_expression_in_builtInCall5517 = new BitSet(new long[]{0x0000000010000000L});
 25260  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5519 = new BitSet(new long[]{0x0000000000000002L});
 25261  2
     public static final BitSet FOLLOW_STRAFTER_in_builtInCall5537 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25262  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5539 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25263  2
     public static final BitSet FOLLOW_expression_in_builtInCall5541 = new BitSet(new long[]{0x0000000200000000L});
 25264  2
     public static final BitSet FOLLOW_COMMA_in_builtInCall5543 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25265  2
     public static final BitSet FOLLOW_expression_in_builtInCall5545 = new BitSet(new long[]{0x0000000010000000L});
 25266  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5547 = new BitSet(new long[]{0x0000000000000002L});
 25267  2
     public static final BitSet FOLLOW_REPLACE_in_builtInCall5565 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25268  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5567 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25269  2
     public static final BitSet FOLLOW_expression_in_builtInCall5569 = new BitSet(new long[]{0x0000000200000000L});
 25270  2
     public static final BitSet FOLLOW_COMMA_in_builtInCall5571 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25271  2
     public static final BitSet FOLLOW_expression_in_builtInCall5573 = new BitSet(new long[]{0x0000000200000000L});
 25272  2
     public static final BitSet FOLLOW_COMMA_in_builtInCall5575 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25273  2
     public static final BitSet FOLLOW_expression_in_builtInCall5577 = new BitSet(new long[]{0x0000000010000000L});
 25274  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5579 = new BitSet(new long[]{0x0000000000000002L});
 25275  2
     public static final BitSet FOLLOW_YEAR_in_builtInCall5599 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25276  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5601 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25277  2
     public static final BitSet FOLLOW_expression_in_builtInCall5603 = new BitSet(new long[]{0x0000000010000000L});
 25278  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5605 = new BitSet(new long[]{0x0000000000000002L});
 25279  2
     public static final BitSet FOLLOW_MONTH_in_builtInCall5621 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25280  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5623 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25281  2
     public static final BitSet FOLLOW_expression_in_builtInCall5625 = new BitSet(new long[]{0x0000000010000000L});
 25282  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5627 = new BitSet(new long[]{0x0000000000000002L});
 25283  2
     public static final BitSet FOLLOW_DAY_in_builtInCall5643 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25284  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5645 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25285  2
     public static final BitSet FOLLOW_expression_in_builtInCall5647 = new BitSet(new long[]{0x0000000010000000L});
 25286  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5649 = new BitSet(new long[]{0x0000000000000002L});
 25287  2
     public static final BitSet FOLLOW_HOURS_in_builtInCall5665 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25288  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5667 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25289  2
     public static final BitSet FOLLOW_expression_in_builtInCall5669 = new BitSet(new long[]{0x0000000010000000L});
 25290  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5671 = new BitSet(new long[]{0x0000000000000002L});
 25291  2
     public static final BitSet FOLLOW_MINUTES_in_builtInCall5687 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25292  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5689 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25293  2
     public static final BitSet FOLLOW_expression_in_builtInCall5691 = new BitSet(new long[]{0x0000000010000000L});
 25294  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5693 = new BitSet(new long[]{0x0000000000000002L});
 25295  2
     public static final BitSet FOLLOW_SECONDS_in_builtInCall5709 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25296  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5711 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25297  2
     public static final BitSet FOLLOW_expression_in_builtInCall5713 = new BitSet(new long[]{0x0000000010000000L});
 25298  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5715 = new BitSet(new long[]{0x0000000000000002L});
 25299  2
     public static final BitSet FOLLOW_TIMEZONE_in_builtInCall5731 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25300  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5733 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25301  2
     public static final BitSet FOLLOW_expression_in_builtInCall5735 = new BitSet(new long[]{0x0000000010000000L});
 25302  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5737 = new BitSet(new long[]{0x0000000000000002L});
 25303  2
     public static final BitSet FOLLOW_TZ_in_builtInCall5753 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25304  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5755 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25305  2
     public static final BitSet FOLLOW_expression_in_builtInCall5757 = new BitSet(new long[]{0x0000000010000000L});
 25306  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5759 = new BitSet(new long[]{0x0000000000000002L});
 25307  2
     public static final BitSet FOLLOW_NOW_in_builtInCall5775 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25308  2
     public static final BitSet FOLLOW_nil_in_builtInCall5777 = new BitSet(new long[]{0x0000000000000002L});
 25309  2
     public static final BitSet FOLLOW_MD5_in_builtInCall5789 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25310  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5791 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25311  2
     public static final BitSet FOLLOW_expression_in_builtInCall5793 = new BitSet(new long[]{0x0000000010000000L});
 25312  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5795 = new BitSet(new long[]{0x0000000000000002L});
 25313  2
     public static final BitSet FOLLOW_SHA1_in_builtInCall5811 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25314  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5813 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25315  2
     public static final BitSet FOLLOW_expression_in_builtInCall5815 = new BitSet(new long[]{0x0000000010000000L});
 25316  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5817 = new BitSet(new long[]{0x0000000000000002L});
 25317  2
     public static final BitSet FOLLOW_SHA224_in_builtInCall5833 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25318  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5835 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25319  2
     public static final BitSet FOLLOW_expression_in_builtInCall5837 = new BitSet(new long[]{0x0000000010000000L});
 25320  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5839 = new BitSet(new long[]{0x0000000000000002L});
 25321  2
     public static final BitSet FOLLOW_SHA256_in_builtInCall5855 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25322  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5857 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25323  2
     public static final BitSet FOLLOW_expression_in_builtInCall5859 = new BitSet(new long[]{0x0000000010000000L});
 25324  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5861 = new BitSet(new long[]{0x0000000000000002L});
 25325  2
     public static final BitSet FOLLOW_SHA384_in_builtInCall5877 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25326  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5879 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25327  2
     public static final BitSet FOLLOW_expression_in_builtInCall5881 = new BitSet(new long[]{0x0000000010000000L});
 25328  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5883 = new BitSet(new long[]{0x0000000000000002L});
 25329  2
     public static final BitSet FOLLOW_SHA512_in_builtInCall5899 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25330  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5901 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25331  2
     public static final BitSet FOLLOW_expression_in_builtInCall5903 = new BitSet(new long[]{0x0000000010000000L});
 25332  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5905 = new BitSet(new long[]{0x0000000000000002L});
 25333  2
     public static final BitSet FOLLOW_COALESCE_in_builtInCall5921 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25334  2
     public static final BitSet FOLLOW_expressionList_in_builtInCall5923 = new BitSet(new long[]{0x0000000000000002L});
 25335  2
     public static final BitSet FOLLOW_IF_in_builtInCall5939 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25336  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5941 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25337  2
     public static final BitSet FOLLOW_expression_in_builtInCall5945 = new BitSet(new long[]{0x0000000200000000L});
 25338  2
     public static final BitSet FOLLOW_COMMA_in_builtInCall5947 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25339  2
     public static final BitSet FOLLOW_expression_in_builtInCall5951 = new BitSet(new long[]{0x0000000200000000L});
 25340  2
     public static final BitSet FOLLOW_COMMA_in_builtInCall5953 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25341  2
     public static final BitSet FOLLOW_expression_in_builtInCall5957 = new BitSet(new long[]{0x0000000010000000L});
 25342  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5959 = new BitSet(new long[]{0x0000000000000002L});
 25343  2
     public static final BitSet FOLLOW_STRLANG_in_builtInCall5982 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25344  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5984 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25345  2
     public static final BitSet FOLLOW_expression_in_builtInCall5986 = new BitSet(new long[]{0x0000000200000000L});
 25346  2
     public static final BitSet FOLLOW_COMMA_in_builtInCall5988 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25347  2
     public static final BitSet FOLLOW_expression_in_builtInCall5990 = new BitSet(new long[]{0x0000000010000000L});
 25348  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5992 = new BitSet(new long[]{0x0000000000000002L});
 25349  2
     public static final BitSet FOLLOW_STRDT_in_builtInCall6010 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25350  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6012 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25351  2
     public static final BitSet FOLLOW_expression_in_builtInCall6014 = new BitSet(new long[]{0x0000000200000000L});
 25352  2
     public static final BitSet FOLLOW_COMMA_in_builtInCall6016 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25353  2
     public static final BitSet FOLLOW_expression_in_builtInCall6018 = new BitSet(new long[]{0x0000000010000000L});
 25354  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6020 = new BitSet(new long[]{0x0000000000000002L});
 25355  2
     public static final BitSet FOLLOW_SAMETERM_in_builtInCall6038 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25356  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6040 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25357  2
     public static final BitSet FOLLOW_expression_in_builtInCall6042 = new BitSet(new long[]{0x0000000200000000L});
 25358  2
     public static final BitSet FOLLOW_COMMA_in_builtInCall6044 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25359  2
     public static final BitSet FOLLOW_expression_in_builtInCall6046 = new BitSet(new long[]{0x0000000010000000L});
 25360  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6048 = new BitSet(new long[]{0x0000000000000002L});
 25361  2
     public static final BitSet FOLLOW_ISIRI_in_builtInCall6066 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25362  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6068 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25363  2
     public static final BitSet FOLLOW_expression_in_builtInCall6070 = new BitSet(new long[]{0x0000000010000000L});
 25364  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6072 = new BitSet(new long[]{0x0000000000000002L});
 25365  2
     public static final BitSet FOLLOW_ISURI_in_builtInCall6088 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25366  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6090 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25367  2
     public static final BitSet FOLLOW_expression_in_builtInCall6092 = new BitSet(new long[]{0x0000000010000000L});
 25368  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6094 = new BitSet(new long[]{0x0000000000000002L});
 25369  2
     public static final BitSet FOLLOW_ISBLANK_in_builtInCall6110 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25370  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6112 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25371  2
     public static final BitSet FOLLOW_expression_in_builtInCall6114 = new BitSet(new long[]{0x0000000010000000L});
 25372  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6116 = new BitSet(new long[]{0x0000000000000002L});
 25373  2
     public static final BitSet FOLLOW_ISLITERAL_in_builtInCall6133 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25374  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6135 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25375  2
     public static final BitSet FOLLOW_expression_in_builtInCall6137 = new BitSet(new long[]{0x0000000010000000L});
 25376  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6139 = new BitSet(new long[]{0x0000000000000002L});
 25377  2
     public static final BitSet FOLLOW_ISNUMERIC_in_builtInCall6155 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25378  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6157 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25379  2
     public static final BitSet FOLLOW_expression_in_builtInCall6159 = new BitSet(new long[]{0x0000000010000000L});
 25380  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6161 = new BitSet(new long[]{0x0000000000000002L});
 25381  2
     public static final BitSet FOLLOW_regexExpression_in_builtInCall6177 = new BitSet(new long[]{0x0000000000000002L});
 25382  2
     public static final BitSet FOLLOW_existsFunction_in_builtInCall6189 = new BitSet(new long[]{0x0000000000000002L});
 25383  2
     public static final BitSet FOLLOW_notExistsFunction_in_builtInCall6201 = new BitSet(new long[]{0x0000000000000002L});
 25384  2
     public static final BitSet FOLLOW_REGEX_in_regexExpression6222 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25385  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_regexExpression6224 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25386  2
     public static final BitSet FOLLOW_expression_in_regexExpression6226 = new BitSet(new long[]{0x0000000200000000L});
 25387  2
     public static final BitSet FOLLOW_COMMA_in_regexExpression6228 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25388  2
     public static final BitSet FOLLOW_expression_in_regexExpression6230 = new BitSet(new long[]{0x0000000210000000L});
 25389  2
     public static final BitSet FOLLOW_COMMA_in_regexExpression6233 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25390  2
     public static final BitSet FOLLOW_expression_in_regexExpression6235 = new BitSet(new long[]{0x0000000010000000L});
 25391  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_regexExpression6239 = new BitSet(new long[]{0x0000000000000002L});
 25392  2
     public static final BitSet FOLLOW_SUBSTR_in_subStringExpression6269 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25393  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_subStringExpression6271 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25394  2
     public static final BitSet FOLLOW_expression_in_subStringExpression6273 = new BitSet(new long[]{0x0000000200000000L});
 25395  2
     public static final BitSet FOLLOW_COMMA_in_subStringExpression6275 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25396  2
     public static final BitSet FOLLOW_expression_in_subStringExpression6277 = new BitSet(new long[]{0x0000000210000000L});
 25397  2
     public static final BitSet FOLLOW_COMMA_in_subStringExpression6280 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25398  2
     public static final BitSet FOLLOW_expression_in_subStringExpression6282 = new BitSet(new long[]{0x0000000010000000L});
 25399  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_subStringExpression6286 = new BitSet(new long[]{0x0000000000000002L});
 25400  2
     public static final BitSet FOLLOW_EXISTS_in_existsFunction6316 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25401  2
     public static final BitSet FOLLOW_groupGraphPattern_in_existsFunction6318 = new BitSet(new long[]{0x0000000000000002L});
 25402  2
     public static final BitSet FOLLOW_NOT_in_notExistsFunction6343 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
 25403  2
     public static final BitSet FOLLOW_EXISTS_in_notExistsFunction6345 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25404  2
     public static final BitSet FOLLOW_groupGraphPattern_in_notExistsFunction6347 = new BitSet(new long[]{0x0000000000000002L});
 25405  2
     public static final BitSet FOLLOW_COUNT_in_aggregate6372 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25406  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6374 = new BitSet(new long[]{0x2720F94884C0C020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25407  2
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6376 = new BitSet(new long[]{0x2700F94884C0C020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25408  2
     public static final BitSet FOLLOW_ASTERISK_in_aggregate6380 = new BitSet(new long[]{0x0000000010000000L});
 25409  2
     public static final BitSet FOLLOW_expression_in_aggregate6384 = new BitSet(new long[]{0x0000000010000000L});
 25410  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6387 = new BitSet(new long[]{0x0000000000000002L});
 25411  2
     public static final BitSet FOLLOW_SUM_in_aggregate6410 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25412  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6412 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25413  2
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6414 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25414  2
     public static final BitSet FOLLOW_expression_in_aggregate6417 = new BitSet(new long[]{0x0000000010000000L});
 25415  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6419 = new BitSet(new long[]{0x0000000000000002L});
 25416  2
     public static final BitSet FOLLOW_MIN_in_aggregate6438 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25417  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6440 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25418  2
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6442 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25419  2
     public static final BitSet FOLLOW_expression_in_aggregate6445 = new BitSet(new long[]{0x0000000010000000L});
 25420  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6447 = new BitSet(new long[]{0x0000000000000002L});
 25421  2
     public static final BitSet FOLLOW_MAX_in_aggregate6466 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25422  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6468 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25423  2
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6470 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25424  2
     public static final BitSet FOLLOW_expression_in_aggregate6473 = new BitSet(new long[]{0x0000000010000000L});
 25425  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6475 = new BitSet(new long[]{0x0000000000000002L});
 25426  2
     public static final BitSet FOLLOW_AVG_in_aggregate6494 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25427  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6496 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25428  2
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6498 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25429  2
     public static final BitSet FOLLOW_expression_in_aggregate6501 = new BitSet(new long[]{0x0000000010000000L});
 25430  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6503 = new BitSet(new long[]{0x0000000000000002L});
 25431  2
     public static final BitSet FOLLOW_SAMPLE_in_aggregate6522 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25432  2
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6524 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25433  2
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6526 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25434  2
     public static final BitSet FOLLOW_expression_in_aggregate6529 = new BitSet(new long[]{0x0000000010000000L});
 25435  2
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6531 = new BitSet(new long[]{0x0000000000000002L});
 25436  2
     public static final BitSet FOLLOW_GROUP_CONCAT_in_aggregate6550 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25437  1
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6552 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25438  1
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6554 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25439  1
     public static final BitSet FOLLOW_expression_in_aggregate6557 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000100000000L});
 25440  1
     public static final BitSet FOLLOW_SEMICOLON_in_aggregate6560 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000200000000L});
 25441  1
     public static final BitSet FOLLOW_SEPARATOR_in_aggregate6562 = new BitSet(new long[]{0x8000000000000000L});
 25442  1
     public static final BitSet FOLLOW_EQUAL_in_aggregate6564 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0007800000000000L});
 25443  1
     public static final BitSet FOLLOW_string_in_aggregate6566 = new BitSet(new long[]{0x0000000010000000L});
 25444  1
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6570 = new BitSet(new long[]{0x0000000000000002L});
 25445  1
     public static final BitSet FOLLOW_iriRef_in_iriRefOrFunction6605 = new BitSet(new long[]{0x0000000000000002L,0x0800000000000000L});
 25446  1
     public static final BitSet FOLLOW_argList_in_iriRefOrFunction6607 = new BitSet(new long[]{0x0000000000000002L});
 25447  1
     public static final BitSet FOLLOW_string_in_rdfLiteral6640 = new BitSet(new long[]{0x0000000000000002L,0x0000001000000000L,0x0000000000800000L});
 25448  1
     public static final BitSet FOLLOW_LANGTAG_in_rdfLiteral6643 = new BitSet(new long[]{0x0000000000000002L});
 25449  1
     public static final BitSet FOLLOW_REFERENCE_in_rdfLiteral6648 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25450  1
     public static final BitSet FOLLOW_iriRef_in_rdfLiteral6650 = new BitSet(new long[]{0x0000000000000002L});
 25451  1
     public static final BitSet FOLLOW_numericLiteralUnsigned_in_numericLiteral6670 = new BitSet(new long[]{0x0000000000000002L});
 25452  1
     public static final BitSet FOLLOW_numericLiteralPositive_in_numericLiteral6678 = new BitSet(new long[]{0x0000000000000002L});
 25453  1
     public static final BitSet FOLLOW_numericLiteralNegative_in_numericLiteral6686 = new BitSet(new long[]{0x0000000000000002L});
 25454  1
     public static final BitSet FOLLOW_IRI_REF_in_iriRef6869 = new BitSet(new long[]{0x0000000000000002L});
 25455  1
     public static final BitSet FOLLOW_prefixedName_in_iriRef6877 = new BitSet(new long[]{0x0000000000000002L});
 25456  1
     public static final BitSet FOLLOW_BLANK_NODE_LABEL_in_blankNode6919 = new BitSet(new long[]{0x0000000000000002L});
 25457  1
     public static final BitSet FOLLOW_anon_in_blankNode6927 = new BitSet(new long[]{0x0000000000000002L});
 25458  1
     public static final BitSet FOLLOW_OPEN_SQUARE_BRACKET_in_anon6944 = new BitSet(new long[]{0x0000000040000000L});
 25459  1
     public static final BitSet FOLLOW_CLOSE_SQUARE_BRACKET_in_anon6946 = new BitSet(new long[]{0x0000000000000002L});
 25460  
 
 25461  
 }